125 lines
3.5 KiB
Swift
125 lines
3.5 KiB
Swift
//
|
|
// 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())!
|
|
}
|
|
}
|