stop reinventing the wheel...; some organization

Author: RandomHashTags

Package.swift

@@ -33,6 +33,9 @@ let package = Package(
             name: "HTMLKitUtilities",
             dependencies: [
                 "HTMLKitUtilityMacros",
+                .product(name: "SwiftDiagnostics", package: "swift-syntax"),
+                .product(name: "SwiftSyntax", package: "swift-syntax"),
+                .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
                 .product(name: "NIOCore", package: "swift-nio")
             ]
         ),

Sources/HTMLKitMacros/HTMLElement.swift

@@ -7,24 +7,6 @@
 
 import SwiftCompilerPlugin
 import SwiftSyntaxMacros
-import SwiftDiagnostics
-
-// MARK: DiagnosticMsg
-struct DiagnosticMsg : DiagnosticMessage {
-    let message:String
-    let diagnosticID:MessageID
-    let severity:DiagnosticSeverity
-
-    init(id: String, message: String, severity: DiagnosticSeverity = .error) {
-        self.message = message
-        self.diagnosticID = MessageID(domain: "HTMLKitMacros", id: id)
-        self.severity = severity
-    }
-}
-extension DiagnosticMsg : FixItMessage {
-    var fixItID : MessageID { diagnosticID }
-}
-
 
 @main
 struct HTMLKitMacros : CompilerPlugin {

Sources/HTMLKitMacros/HTMLKitMacros.swift

@@ -49,7 +49,10 @@ public extension HTMLElementAttribute {
 
         public init?(rawValue: String) {
             guard rawValue.last == ")" else { return nil }
-            let key:Substring = rawValue.split(separator: "(")[0]
+            var key:Substring = rawValue.split(separator: "(")[0]
+            if key.hasPrefix("hx-") {
+                key.removeFirst(3)
+            }
             func literal() -> String        { HTMLElementAttribute.literal(key: key, rawValue: rawValue) }
             func string() -> String         { HTMLElementAttribute.string(key: key, rawValue: rawValue) }
             func boolean() -> Bool          { HTMLElementAttribute.boolean(key: key, rawValue: rawValue) }
@@ -261,7 +264,7 @@ public extension HTMLElementAttribute {
                         return ""
                     }
                 case .sync(let selector, let strategy):
-                    return selector + (strategy == nil ? "" : ":" + strategy!.htmlValue)
+                    return selector + (strategy == nil ? "" : ":" + strategy!.htmlValue!)
                 case .validate(let value): return value.rawValue
 
                 case .get(let value):  return value
@@ -282,304 +285,4 @@ public extension HTMLElementAttribute {
             }
         }
     }
-}
-
-// MARK: Attributes
-
-
-
-
-public extension HTMLElementAttribute.HTMX {
-    // MARK: Boost
-    enum TrueOrFalse : String, HTMLInitializable {
-        case `true`, `false`
-    }
-
-    // MARK: Event
-    enum Event : String {
-        case abort
-        case afterOnLoad
-        case afterProcessNode
-        case afterRequest
-        case afterSettle
-        case afterSwap
-        case beforeCleanupElement
-        case beforeOnLoad
-        case beforeProcessNode
-        case beforeRequest
-        case beforeSend
-        case beforeSwap
-        case beforeTransition
-        case configRequest
-        case confirm
-        case historyCacheError
-        case historyCacheMiss
-        case historyCacheMissError
-        case historyCacheMissLoad
-        case historyRestore
-        case beforeHistorySave
-        case load
-        case noSSESourceError
-        case onLoadError
-        case oobAfterSwap
-        case oobBeforeSwap
-        case oobErrorNoTarget
-        case prompt
-        case beforeHistoryUpdate
-        case pushedIntoHistory
-        case replacedInHistory
-        case responseError
-        case sendError
-        case sseError
-        case sseOpen
-        case swapError
-        case targetError
-        case timeout
-        case trigger
-        case validateURL
-        case validationValidate
-        case validationFailed
-        case validationHalted
-        case xhrAbort
-        case xhrLoadEnd
-        case xhrLoadStart
-        case xhrProgress
-
-        public var key : String {
-            func slug() -> String {
-                switch self {
-                    case .afterOnLoad:           return "after-on-load"
-                    case .afterProcessNode:      return "after-process-node"
-                    case .afterRequest:          return "after-request"
-                    case .afterSettle:           return "after-settle"
-                    case .afterSwap:             return "after-swap"
-                    case .beforeCleanupElement:  return "before-cleanup-element"
-                    case .beforeOnLoad:          return "before-on-load"
-                    case .beforeProcessNode:     return "before-process-node"
-                    case .beforeRequest:         return "before-request"
-                    case .beforeSend:            return "before-send"
-                    case .beforeSwap:            return "before-swap"
-                    case .beforeTransition:      return "before-transition"
-                    case .configRequest:         return "config-request"
-                    case .historyCacheError:     return "history-cache-error"
-                    case .historyCacheMiss:      return "history-cache-miss"
-                    case .historyCacheMissError: return "history-cache-miss-error"
-                    case .historyCacheMissLoad:  return "history-cache-miss-load"
-                    case .historyRestore:        return "history-restore"
-                    case .beforeHistorySave:     return "before-history-save"
-                    case .noSSESourceError:      return "no-sse-source-error"
-                    case .onLoadError:           return "on-load-error"
-                    case .oobAfterSwap:          return "oob-after-swap"
-                    case .oobBeforeSwap:         return "oob-before-swap"
-                    case .oobErrorNoTarget:      return "oob-error-no-target"
-                    case .beforeHistoryUpdate:   return "before-history-update"
-                    case .pushedIntoHistory:     return "pushed-into-history"
-                    case .replacedInHistory:     return "replaced-in-history"
-                    case .responseError:         return "response-error"
-                    case .sendError:             return "send-error"
-                    case .sseError:              return "sse-error"
-                    case .sseOpen:               return "sse-open"
-                    case .swapError:             return "swap-error"
-                    case .targetError:           return "target-error"
-                    case .validateURL:           return "validate-url"
-                    case .validationValidate:    return "validation:validate"
-                    case .validationFailed:      return "validation:failed"
-                    case .validationHalted:      return "validation:halted"
-                    case .xhrAbort:              return "xhr:abort"
-                    case .xhrLoadEnd:            return "xhr:loadend"
-                    case .xhrLoadStart:          return "xhr:loadstart"
-                    case .xhrProgress:           return "xhr:progress"
-                    default:                     return rawValue
-                }
-            }
-            return ":" + slug()
-        }
-    }
-
-    // MARK: Params
-    enum Params {
-        case all
-        case none
-        case not([String])
-        case list([String])
-
-        public init?(rawValue: String) {
-            let key:Substring = rawValue.split(separator: "(")[0]
-            func array_string() -> [String] {
-                let string:String = String(rawValue[rawValue.index(rawValue.startIndex, offsetBy: key.count + 2)..<rawValue.index(before: rawValue.endIndex)])
-                let ranges:[Range<String.Index>] = try! string.ranges(of: Regex("\"([^\"]+)\"")) // TODO: fix? (doesn't parse correctly if the string contains escaped quotation marks)
-                return ranges.map({
-                    let item:String = String(string[$0])
-                    return String(item[item.index(after: item.startIndex)..<item.index(before: item.endIndex)])
-                })
-            }
-            switch key {
-                case "all":  self = .all
-                case "none": self = .none
-                case "not":  self = .not(array_string())
-                case "list": self = .list(array_string())
-                default: return nil
-            }
-        }
-
-        public var htmlValue : String {
-            switch self {
-                case .all:             return "*"
-                case .none:            return "none"
-                case .not(let list):  return "not " + list.joined(separator: ",")
-                case .list(let list): return list.joined(separator: ",")
-            }
-        }
-    }
-
-    // MARK: Swap
-    enum Swap : String, HTMLInitializable {
-        case innerHTML, outerHTML
-        case textContent
-        case beforebegin, afterbegin
-        case beforeend, afterend
-        case delete, none
-    }
-
-    // MARK: Sync
-    enum SyncStrategy {
-        case drop, abort, replace
-        case queue(Queue)
-
-        public init?(rawValue: String) {
-            let values:[Substring] = rawValue.split(separator: "(")
-            switch values[0] {
-                case "drop":    self = .drop
-                case "abort":   self = .abort
-                case "replace": self = .replace
-                case "queue":
-                    guard let value_index:Substring.Index = values[1].firstIndex(where: { $0.isLetter }) else { return nil }
-                    let value:Substring = rawValue[value_index..<values[1].index(before: values[1].endIndex)]
-                    self = .queue(Queue(rawValue: String(value))!)
-                    break
-                default:        return nil
-            }
-        }
-
-        public enum Queue : String {
-            case first, last, all
-        }
-
-        public var htmlValue : String {
-            switch self {
-                case .drop:             return "drop"
-                case .abort:            return "abort"
-                case .replace:          return "replace"
-                case .queue(let queue): return "queue " + queue.rawValue
-            }
-        }
-    }
-
-    // MARK: URL
-    enum URL {
-        case `true`, `false`
-        case url(String)
-
-        public init?(rawValue: String) {
-            let key:Substring = rawValue.split(separator: "(")[0]
-            switch key {
-                case "true": self = .true
-                case "false": self = .false
-                case "url": self = .url(HTMLElementAttribute.string(key: key, rawValue: rawValue))
-                default: return nil
-            }
-        }
-
-        public var htmlValue : String {
-            switch self {
-                case .true: return "true"
-                case .false: return "false"
-                case .url(let url): return url.hasPrefix("http://") || url.hasPrefix("https://") ? url : (url.first == "/" ? "" : "/") + url
-            }
-        }
-    }
-}
-
-// MARK: Server Sent Events
-public extension HTMLElementAttribute.HTMX {
-    enum ServerSentEvents {
-        case connect(String)
-        case swap(String)
-        case close(String)
-
-        public init?(rawValue: String) {
-            guard rawValue.last == ")" else { return nil }
-            let key:Substring = rawValue.split(separator: "(")[0]
-            func string() -> String { HTMLElementAttribute.string(key: key, rawValue: rawValue) }
-            switch key {
-                case "connect": self = .connect(string())
-                case "swap": self = .swap(string())
-                case "close": self = .close(string())
-                default: return nil
-            }
-        }
-
-        public var key : String {
-            switch self {
-                case .connect(_): return "connect"
-                case .swap(_): return "swap"
-                case .close(_): return "close"
-            }
-        }
-
-        public var htmlValue : String {
-            switch self {
-                case .connect(let value),
-                        .swap(let value),
-                        .close(let value):
-                    return value
-            }
-        }
-    }
-}
-
-// MARK: WebSocket
-public extension HTMLElementAttribute.HTMX {
-    enum WebSocket {
-        case connect(String)
-        case send(Bool)
-
-        public init?(rawValue: String) {
-            guard rawValue.last == ")" else { return nil }
-            let key:Substring = rawValue.split(separator: "(")[0]
-            func string() -> String { HTMLElementAttribute.string(key: key, rawValue: rawValue) }
-            func boolean() -> Bool  { HTMLElementAttribute.boolean(key: key, rawValue: rawValue) }
-            switch key {
-                case "connect": self = .connect(string())
-                case "send": self = .send(boolean())
-                default: return nil
-            }
-        }
-
-        public var key : String {
-            switch self {
-                case .connect(_): return "connect"
-                case .send(_): return "send"
-            }
-        }
-
-        public var htmlValue : String {
-            switch self {
-                case .connect(let value): return value
-                case .send(_): return ""
-            }
-        }
-
-        public enum Event : String {
-            case wsConnecting
-            case wsOpen
-            case wsClose
-            case wsError
-            case wsBeforeMessage
-            case wsAfterMessage
-            case wsConfigSend
-            case wsBeforeSend
-            case wsAfterSend
-        }
-    }
 }