Initial Commit

Sources/HRW/Internal/GlobalEnums.swift

@@ -0,0 +1,124 @@
+//
+//  GlobalEnums.swift
+//  HRW
+//
+//  Created by Isaac Paul on 10/19/24.
+//  Non-commercial license, see LICENSE.MD in the project root for details
+//
+import Foundation
+
+//Some bike shedding to avoid allocations
+struct ComponentsIterator: IteratorProtocol {
+    let string: String
+    let splitCharacter: Character
+    var currentIndex: String.Index
+
+    init(_ string: String, separatedBy: Character) {
+        self.string = string
+        self.splitCharacter = separatedBy
+        self.currentIndex = string.startIndex
+    }
+
+    mutating func next() -> Substring? {
+        // Skip any leading split characters
+        while currentIndex < string.endIndex && string[currentIndex] == splitCharacter {
+            currentIndex = string.index(after: currentIndex)
+        }
+
+        // Check if we've reached the end of the string
+        if currentIndex >= string.endIndex {
+            return nil
+        }
+
+        let start = currentIndex
+        while currentIndex < string.endIndex && string[currentIndex] != splitCharacter {
+            currentIndex = string.index(after: currentIndex)
+        }
+
+        return string[start..<currentIndex]
+    }
+}
+
+extension IteratorProtocol {
+    mutating func map<R>(_ block: (_ input:Element) throws -> R) rethrows -> [R] {
+        var result:[R] = []
+        while let item = self.next() {
+            result.append(try block(item))
+        }
+        return result
+    }
+}
+
+extension String {
+    func componentsIterator(separatedBy: Character) -> ComponentsIterator {
+        return ComponentsIterator(self, separatedBy: separatedBy)
+    }
+    
+    func componentsIterator(separatedBy: String) -> ComponentsIterator {
+        return ComponentsIterator(self, separatedBy: separatedBy.first!)
+    }
+}
+
+
+public enum ShadowRootMode : Substring {
+    case open = "open"   ///The template element represents an open declarative shadow root.
+    case close = "close" ///The template element represents a closed declarative shadow root.
+    
+    public init?(rawValue: String) {
+        self.init(rawValue: rawValue.asSubstring())
+    }
+}
+
+
+public enum Blocking : Substring {
+    case render = "render"
+    
+    static func parseList(_ value:String?) throws -> [Blocking] {
+        guard let value = value else { return [] }
+        var iterator = value.componentsIterator(separatedBy: " ")
+        let result = try iterator.map { input in
+            return try expect(Blocking(rawValue: input), "unexpected value for blocking: \(input)")
+        }
+        return result
+    }
+}
+
+public enum FetchPriority : Substring {
+    case high = "high"
+    case low = "low"
+    case auto = "auto"
+    
+    public init?(rawValue: String) {
+        self.init(rawValue: rawValue.asSubstring())
+    }
+    
+    public init(expect: String) throws {
+        guard let _ = FetchPriority(rawValue: expect) else {
+            throw AppError("Unexpected value for Fetch Priority: \(expect)")
+        }
+        self.init(rawValue: expect.asSubstring())!
+    }
+}
+
+public enum Preload : Substring {
+    case none = "none"
+    case auto = "auto"
+    case metadata = "metadata"
+    
+    public init?(rawValue: String) {
+        self.init(rawValue: rawValue.asSubstring())
+    }
+    
+    public init(expect: String) throws {
+        let strToUse:String
+        if (expect.count == 0) {
+            strToUse = "auto"
+        } else {
+            strToUse = expect
+        }
+        guard let _ = Preload(rawValue: strToUse) else {
+            throw AppError("Unexpected value for Preload \(strToUse)")
+        }
+        self.init(rawValue: strToUse.asSubstring())!
+    }
+}