SwiftUI+ComponentState.swift

public enum ComponentState<T: Sendable>: Sendable {
    case `default`
    case loading(T)
    case loaded(T)
    case error(T)
    
    public var isLoading: Bool {
        switch self {
        case .loading: true
        default: false
        }
    }
    
    public var isLoaded: Bool {
        switch self {
        case .loaded: true
        default: false
        }
    }
}
    
extension ComponentState where T: RangeReplaceableCollection {
    
    public var components: T {
        switch self {
        case .default: T()
        case .loading(let components): components
        case .loaded(let components): components
        case .error(let components): components
        }
    }
    
    public var count: Int {
        components.count
    }
    
    public var isEmpty: Bool {
        components.isEmpty
    }
    
    public mutating func append(contentsOf newComponents: T) {
        switch self {
        case .default:
            break
        case .loading:
            var current = self.components
            current.append(contentsOf: newComponents)
            self = .loading(current)
        case .loaded:
            var current = self.components
            current.append(contentsOf: newComponents)
            self = .loaded(current)
        case .error:
            var current = self.components
            current.append(contentsOf: newComponents)
            self = .error(current)
        }
    }
    
    /// Removes components at the specified range of indices (more efficient than filtering)
    public mutating func remove(at range: Range<Int>) where T.Index == Int {
        switch self {
        case .default:
            break
        case .loading:
            var current = self.components
            current.removeSubrange(range)
            self = .loading(current)
        case .loaded:
            var current = self.components
            current.removeSubrange(range)
            self = .loaded(current)
        case .error:
            var current = self.components
            current.removeSubrange(range)
            self = .error(current)
        }
    }
    
    /// Removes the last N components (efficient for removing appended loading components)
    public mutating func removeLast(_ count: Int) where T.Index == Int {
        guard count > 0, self.count >= count else { return }
        let startIndex = self.count - count
        remove(at: startIndex..<self.count)
    }
}