minor changes & performance improvements + possible fix for missing modules

RandomHashTags · RandomHashTags · commit 26c72f7bf970 · 2025-04-01T14:32:54.000-05:00
diff --git a/Package.swift b/Package.swift
@@ -103,9 +103,13 @@ let package = Package(
         .target(
             name: "HTMLKit",
             dependencies: [
+                "CSS",
                 "HTMLAttributes",
+                "HTMLElements",
+                "HTMLKitParse",
                 "HTMLKitUtilities",
-                "HTMLKitMacros"
+                "HTMLKitMacros",
+                "HTMX"
             ]
         ),
 
diff --git a/Sources/HTMLKitParse/ParseData.swift b/Sources/HTMLKitParse/ParseData.swift
@@ -69,36 +69,26 @@ extension HTMLKitUtilities {
         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 hasNoInterpolation() -> Bool {
-            let hasInterpolation:Bool = !string.ranges(of: try! Regex("\\((.*)\\)")).isEmpty
-            guard !hasInterpolation else {
-                if !context.ignoresCompilerWarnings {
-                    context.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 false
-            }
-            return true
-        }
         func bytes<T: FixedWidthInteger>(_ bytes: [T]) -> String {
             return "[" + bytes.map({ "\($0)" }).joined(separator: ",") + "]"
         }
         switch encoding {
         case .utf8Bytes:
-            guard hasNoInterpolation() else { return "" }
+            guard hasNoInterpolation(context, node, string) else { return "" }
             return bytes([UInt8](string.utf8))
         case .utf16Bytes:
-            guard hasNoInterpolation() else { return "" }
+            guard hasNoInterpolation(context, node, string) else { return "" }
             return bytes([UInt16](string.utf16))
         case .utf8CString:
-            guard hasNoInterpolation() else { return "" }
+            guard hasNoInterpolation(context, node, string) else { return "" }
             return "\(string.utf8CString)"
 
         case .foundationData:
-            guard hasNoInterpolation() else { return "" }
+            guard hasNoInterpolation(context, node, string) else { return "" }
             return "Data(\(bytes([UInt8](string.utf8))))"
 
         case .byteBuffer:
-            guard hasNoInterpolation() else { return "" }
+            guard hasNoInterpolation(context, node, string) else { return "" }
             return "ByteBuffer(bytes: \(bytes([UInt8](string.utf8))))"
 
         case .string:
@@ -107,14 +97,23 @@ extension HTMLKitUtilities {
             return encoded.replacingOccurrences(of: "$0", with: string)
         }
     }
+    private static func hasNoInterpolation(_ context: HTMLExpansionContext, _ node: MacroExpansionExprSyntax, _ string: String) -> Bool {
+        guard string.firstRange(of: try! Regex("\\((.*)\\)")) == nil else {
+            if !context.ignoresCompilerWarnings {
+                context.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 intended result.")))
+            }
+            return false
+        }
+        return true
+    }
 
     // MARK: Parse Arguments
     public static func parseArguments(
         context: HTMLExpansionContext,
         otherAttributes: [String:String] = [:]
     ) -> ElementData {
         var context = context
-        var global_attributes:[HTMLAttribute] = []
+        var globalAttributes:[HTMLAttribute] = []
         var attributes:[String:Sendable] = [:]
         var innerHTML:[CustomStringConvertible & Sendable] = []
         var trailingSlash:Bool = false
@@ -129,7 +128,7 @@ extension HTMLKitUtilities {
                     case "lookupFiles":
                         context.lookupFiles = Set(child.expression.array!.elements.compactMap({ $0.expression.stringLiteral?.string(encoding: context.encoding) }))
                     case "attributes":
-                        (global_attributes, trailingSlash) = parseGlobalAttributes(context: context, array: child.expression.array!.elements)
+                        (globalAttributes, trailingSlash) = parseGlobalAttributes(context: context, array: child.expression.array!.elements)
                     default:
                         context.key = otherAttributes[key] ?? key
                         if let test = HTMLAttribute.Extra.parse(context: context, expr: child.expression) {
@@ -141,8 +140,7 @@ extension HTMLKitUtilities {
                             case .int(let i): attributes[key] = i
                             case .float(let f): attributes[key] = f
                             case .array:
-                                let escaped:LiteralReturnType = literal.escapeArray()
-                                switch escaped {
+                                switch literal.escapeArray() {
                                 case .array(let a): attributes[key] = a
                                 default: break
                                 }
@@ -169,27 +167,30 @@ extension HTMLKitUtilities {
                 }
             }
         }
-        return ElementData(context.encoding, global_attributes, attributes, innerHTML, trailingSlash)
+        return ElementData(context.encoding, globalAttributes, attributes, innerHTML, trailingSlash)
     }
 
     // MARK: Parse Encoding
     public static func parseEncoding(expression: ExprSyntax) -> HTMLEncoding? {
-        if let key = expression.memberAccess?.declName.baseName.text {
-            return HTMLEncoding(rawValue: key)
-        } else if let function = expression.functionCall {
+        switch expression.kind {
+        case .memberAccessExpr:
+            return HTMLEncoding(rawValue: expression.memberAccess!.declName.baseName.text)
+        case .functionCallExpr:
+            let function = expression.functionCall!
             switch function.calledExpression.as(MemberAccessExprSyntax.self)?.declName.baseName.text {
             case "custom":
-                guard let logic = function.arguments.first?.expression.stringLiteral?.string(encoding: .string) else { break }
+                guard let logic = function.arguments.first?.expression.stringLiteral?.string(encoding: .string) else { return nil }
                 if function.arguments.count == 1 {
                     return .custom(logic)
                 } else {
                     return .custom(logic, stringDelimiter: function.arguments.last!.expression.stringLiteral!.string(encoding: .string))
                 }
             default:
-                break
+                return nil
             }
+        default:
+            return nil
         }
-        return nil
     }
 
     // MARK: Parse Global Attributes
@@ -328,13 +329,13 @@ extension HTMLKitUtilities {
 
 // MARK: Misc
 extension ExprSyntax {
-    package func string(context: HTMLExpansionContext) -> String? {
+    package func string(_ context: HTMLExpansionContext) -> String? {
         return HTMLKitUtilities.parseLiteralValue(context: context, expression: self)?.value(key: context.key)
     }
-    package func boolean(context: HTMLExpansionContext) -> Bool? {
+    package func boolean(_ context: HTMLExpansionContext) -> Bool? {
         booleanLiteral?.literal.text == "true"
     }
-    package func enumeration<T : HTMLParsable>(context: HTMLExpansionContext) -> T? {
+    package func enumeration<T : HTMLParsable>(_ context: HTMLExpansionContext) -> T? {
         if let function = functionCall, let member = function.calledExpression.memberAccess {
             var c = context
             c.key = member.declName.baseName.text
@@ -348,28 +349,28 @@ extension ExprSyntax {
         }
         return nil
     }
-    package func int(context: HTMLExpansionContext) -> Int? {
+    package func int(_ context: HTMLExpansionContext) -> Int? {
         guard let s = HTMLKitUtilities.parseLiteralValue(context: context, expression: self)?.value(key: context.key) else { return nil }
         return Int(s)
     }
-    package func arrayString(context: HTMLExpansionContext) -> [String]? {
-        array?.elements.compactMap({ $0.expression.string(context: context) })
+    package func arrayString(_ context: HTMLExpansionContext) -> [String]? {
+        array?.elements.compactMap({ $0.expression.string(context) })
     }
-    package func arrayEnumeration<T: HTMLParsable>(context: HTMLExpansionContext) -> [T]? {
-        array?.elements.compactMap({ $0.expression.enumeration(context: context) })
+    package func arrayEnumeration<T: HTMLParsable>(_ context: HTMLExpansionContext) -> [T]? {
+        array?.elements.compactMap({ $0.expression.enumeration(context) })
     }
-    package func dictionaryStringString(context: HTMLExpansionContext) -> [String:String] {
+    package func dictionaryStringString(_ context: HTMLExpansionContext) -> [String:String] {
         var d:[String:String] = [:]
         if let elements = dictionary?.content.as(DictionaryElementListSyntax.self) {
             for element in elements {
-                if let key = element.key.string(context: context), let value = element.value.string(context: context) {
+                if let key = element.key.string(context), let value = element.value.string(context) {
                     d[key] = value
                 }
             }
         }
         return d
     }
-    package func float(context: HTMLExpansionContext) -> Float? {
+    package func float(_ context: HTMLExpansionContext) -> Float? {
         guard let s = HTMLKitUtilities.parseLiteralValue(context: context, expression: self)?.value(key: context.key) else { return nil }
         return Float(s)
     }
@@ -391,11 +392,11 @@ package struct DiagnosticMsg : DiagnosticMessage, FixItMessage {
 
 // MARK: HTMLExpansionContext
 extension HTMLExpansionContext {
-    func string() -> String? { expression?.string(context: self) }
-    func boolean() -> Bool?  { expression?.boolean(context: self) }
-    func enumeration<T : HTMLParsable>() -> T? { expression?.enumeration(context: self) }
-    func int() -> Int? { expression?.int(context: self) }
-    func float() -> Float? { expression?.float(context: self) }
-    func arrayString() -> [String]? { expression?.arrayString(context: self) }
-    func arrayEnumeration<T: HTMLParsable>() -> [T]? { expression?.arrayEnumeration(context: self) }
+    func string() -> String? { expression?.string(self) }
+    func boolean() -> Bool?  { expression?.boolean(self) }
+    func enumeration<T : HTMLParsable>() -> T? { expression?.enumeration(self) }
+    func int() -> Int? { expression?.int(self) }
+    func float() -> Float? { expression?.float(self) }
+    func arrayString() -> [String]? { expression?.arrayString(self) }
+    func arrayEnumeration<T: HTMLParsable>() -> [T]? { expression?.arrayEnumeration(self) }
 }
diff --git a/Sources/HTMLKitParse/ParseLiteral.swift b/Sources/HTMLKitParse/ParseLiteral.swift
@@ -16,19 +16,7 @@ extension HTMLKitUtilities {
         context: HTMLExpansionContext,
         expression: ExprSyntax
     ) -> LiteralReturnType? {
-        switch expression.kind {
-        case .booleanLiteralExpr:
-            return .boolean(expression.booleanLiteral?.literal.text == "true")
-        case .integerLiteralExpr:
-            return .int(Int(expression.integerLiteral!.literal.text)!)
-        case .floatLiteralExpr:
-            return .float(Float(expression.floatLiteral!.literal.text)!)
-        default:
-            break
-        }
-        guard var returnType = extractLiteral(context: context, expression: expression) else {
-            return nil
-        }
+        guard let returnType = extractLiteral(context: context, expression: expression) else { return nil }
         guard returnType.isInterpolation else { return returnType }
         var remainingInterpolation:Int = 1
         var string:String
@@ -40,8 +28,8 @@ extension HTMLKitUtilities {
                 segments.append(segment)
                 if let expression = segment.as(ExpressionSegmentSyntax.self) {
                     interpolation.append(expression)
+                    remainingInterpolation += 1
                 }
-                remainingInterpolation += segment.is(StringSegmentSyntax.self) ? 0 : 1
             }
             var minimum:Int = 0
             for expr in interpolation {
@@ -77,29 +65,17 @@ extension HTMLKitUtilities {
         }
         // TODO: promote interpolation via lookupFiles here (remove `warnInterpolation` above and from `promoteInterpolation`)
         if remainingInterpolation > 0 {
-            returnType = .interpolation(string)
+            return .interpolation(string)
         } else {
-            returnType = .string(string)
+            return .string(string)
         }
-        return returnType
     }
     // MARK: Promote Interpolation
     static func promoteInterpolation(
         context: HTMLExpansionContext,
         remainingInterpolation: inout Int,
         expr: ExpressionSegmentSyntax
     ) -> [any (SyntaxProtocol & SyntaxHashable)] {
-        func create(_ string: String) -> StringLiteralExprSyntax {
-            var s = StringLiteralExprSyntax(content: string)
-            s.openingQuote = TokenSyntax(stringLiteral: "")
-            s.closingQuote = TokenSyntax(stringLiteral: "")
-            return s
-        }
-        func interpolate(_ syntax: ExprSyntaxProtocol) -> ExpressionSegmentSyntax {
-            var list = LabeledExprListSyntax()
-            list.append(LabeledExprSyntax(expression: syntax))
-            return ExpressionSegmentSyntax(expressions: list)
-        }
         var values:[any (SyntaxProtocol & SyntaxHashable)] = []
         for element in expr.expressions {
             let expression = element.expression
@@ -131,13 +107,32 @@ extension HTMLKitUtilities {
         }
         return values
     }
+    static func create(_ string: String) -> StringLiteralExprSyntax {
+        var s = StringLiteralExprSyntax(content: string)
+        s.openingQuote = TokenSyntax(stringLiteral: "")
+        s.closingQuote = TokenSyntax(stringLiteral: "")
+        return s
+    }
+    static func interpolate(_ syntax: ExprSyntaxProtocol) -> ExpressionSegmentSyntax {
+        var list = LabeledExprListSyntax()
+        list.append(LabeledExprSyntax(expression: syntax))
+        return ExpressionSegmentSyntax(expressions: list)
+    }
+
     // MARK: Extract Literal
     static func extractLiteral(
         context: HTMLExpansionContext,
         expression: ExprSyntax
     ) -> LiteralReturnType? {
         switch expression.kind {
-        case .nilLiteralExpr: return nil
+        case .nilLiteralExpr:
+            return nil
+        case .booleanLiteralExpr:
+            return .boolean(expression.booleanLiteral!.literal.text == "true")
+        case .integerLiteralExpr:
+            return .int(Int(expression.integerLiteral!.literal.text)!)
+        case .floatLiteralExpr:
+            return .float(Float(expression.floatLiteral!.literal.text)!)
         case .memberAccessExpr, .forceUnwrapExpr:
             return .interpolation("\(expression)")
         case .stringLiteralExpr:
@@ -260,6 +255,7 @@ public enum LiteralReturnType {
 
 // MARK: Misc
 extension MemberAccessExprSyntax {
+    @inlinable
     var singleLineDescription : String {
         var string = "\(self)"
         string.removeAll { $0.isWhitespace }
diff --git a/Sources/HTMLKitParse/extensions/HTMLElementValueType.swift b/Sources/HTMLKitParse/extensions/HTMLElementValueType.swift
@@ -12,8 +12,7 @@ import SwiftSyntax
 
 extension HTMLElementValueType {
     package static func get<T: HTMLElement>(_ context: HTMLExpansionContext, _ bruh: T.Type) -> T {
-        let data = HTMLKitUtilities.parseArguments(context: context, otherAttributes: T.otherAttributes)
-        return T(context.encoding, data)
+        return T(context.encoding, HTMLKitUtilities.parseArguments(context: context, otherAttributes: T.otherAttributes))
     }
     package static func parseElement(
         context: HTMLExpansionContext,
diff --git a/Sources/HTMLKitParse/extensions/HTMX.swift b/Sources/HTMLKitParse/extensions/HTMX.swift
@@ -23,7 +23,7 @@ extension HTMXAttribute : HTMLParsable {
         case "disinherit": self = .disinherit(string())
         case "encoding": self = .encoding(string())
         case "ext": self = .ext(string())
-        case "headers": self = .headers(js: boolean() ?? false, context.arguments.last!.expression.dictionaryStringString(context: context))
+        case "headers": self = .headers(js: boolean() ?? false, context.arguments.last!.expression.dictionaryStringString(context))
         case "history": self = .history(enumeration())
         case "historyElt": self = .historyElt(boolean())
         case "include": self = .include(string())
@@ -37,19 +37,19 @@ extension HTMXAttribute : HTMLParsable {
         case "replaceURL": self = .replaceURL(enumeration())
         case "request":
             guard let js = boolean() else { return nil }
-            let timeout = context.arguments.get(1)?.expression.string(context: context)
-            let credentials = context.arguments.get(2)?.expression.string(context: context)
-            let noHeaders = context.arguments.get(3)?.expression.string(context: context)
+            let timeout = context.arguments.getPositive(1)?.expression.string(context)
+            let credentials = context.arguments.getPositive(2)?.expression.string(context)
+            let noHeaders = context.arguments.getPositive(3)?.expression.string(context)
             self = .request(js: js, timeout: timeout, credentials: credentials, noHeaders: noHeaders)
         case "sync":
             guard let s = string() else { return nil }
-            self = .sync(s, strategy: context.arguments.last!.expression.enumeration(context: context))
+            self = .sync(s, strategy: context.arguments.last!.expression.enumeration(context))
         case "validate": self = .validate(enumeration())
 
         case "get": self = .get(string())
         case "post": self = .post(string())
         case "on", "onevent":
-            guard let s = context.arguments.last?.expression.string(context: context) else { return nil }
+            guard let s = context.arguments.last?.expression.string(context) else { return nil }
             if context.key == "on" {
                 self = .on(enumeration(), s)
             } else {
diff --git a/Sources/HTMLKitParse/extensions/html/HTMLAttributes.swift b/Sources/HTMLKitParse/extensions/html/HTMLAttributes.swift
@@ -23,7 +23,7 @@ extension HTMLAttribute : HTMLParsable {
         case "class":                 self = .class(arrayString())
         case "contenteditable":       self = .contenteditable(enumeration())
         case "data", "custom":
-            guard let id = string(), let value = context.arguments.last?.expression.string(context: context) else {
+            guard let id = string(), let value = context.arguments.last?.expression.string(context) else {
                 return nil
             }
             if context.key == "data" {
@@ -64,7 +64,7 @@ extension HTMLAttribute : HTMLParsable {
         case "trailingSlash":         self = .trailingSlash
         case "htmx":                  self = .htmx(enumeration())
         case "event":
-            guard let event:HTMLEvent = enumeration(), let value = context.arguments.last?.expression.string(context: context) else {
+            guard let event:HTMLEvent = enumeration(), let value = context.arguments.last?.expression.string(context) else {
                 return nil
             }
             self = .event(event, value)
diff --git a/Sources/HTMLKitUtilities/HTMLElementType.swift b/Sources/HTMLKitUtilities/HTMLElementType.swift
@@ -5,7 +5,7 @@
 //  Created by Evan Anderson on 11/21/24.
 //
 
-public enum HTMLElementType : String, CaseIterable, Sendable {
+public enum HTMLElementType : String, Sendable {
     case html
     
     case a
diff --git a/Sources/HTMLKitUtilities/HTMLEncoding.swift b/Sources/HTMLKitUtilities/HTMLEncoding.swift
@@ -64,6 +64,7 @@ public enum HTMLEncoding : Sendable {
     /// 
     case custom(_ logic: String, stringDelimiter: String = "\\\"")
 
+    @inlinable
     public init?(rawValue: String) {
         switch rawValue {
         case "string": self = .string
diff --git a/Sources/HTMLKitUtilities/HTMLInitializable.swift b/Sources/HTMLKitUtilities/HTMLInitializable.swift
diff --git a/Sources/HTMLKitUtilities/HTMLKitUtilities.swift b/Sources/HTMLKitUtilities/HTMLKitUtilities.swift
diff --git a/Sources/HTMLKitUtilities/Minify.swift b/Sources/HTMLKitUtilities/Minify.swift

Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,7 @@ import SwiftSyntax`
`12`	`12`
`13`	`13`	`extension HTMLElementValueType {`
`14`	`14`	`package static func get<T: HTMLElement>(_ context: HTMLExpansionContext, _ bruh: T.Type) -> T {`
`15`		`- let data = HTMLKitUtilities.parseArguments(context: context, otherAttributes: T.otherAttributes)`
`16`		`- return T(context.encoding, data)`
	`15`	`+ return T(context.encoding, HTMLKitUtilities.parseArguments(context: context, otherAttributes: T.otherAttributes))`
`17`	`16`	`}`
`18`	`17`	`package static func parseElement(`
`19`	`18`	`context: HTMLExpansionContext,`