IanKeen

public protocol KeyPathComponent { }

extension String: KeyPathComponent { }
extension Int: KeyPathComponent { }

public protocol KeyPathAccessible {
    func value<T>(at component: KeyPathComponent) -> T?
}

extension KeyPathAccessible {

IanKeen

import SwiftUI

extension Array {
    func chunk(size: Int) -> [[Element]] {
        return stride(from: 0, to: count, by: size).map {
            return Array(self[$0..<Swift.min($0 + size, count)])
        }
    }
}

IanKeen

import UIKit

open class TextView: UITextView {
    // MARK: - Public Properties
    public var autoSizing: Bool = false {
        didSet { redraw() }
    }
    public var minimumLines: Int = 1 {
        didSet { redraw() }
    }

IanKeen

public typealias LosslessStringCodable = LosslessStringConvertible & Codable

public struct Value<T: LosslessStringCodable>: Codable {
    private let type: LosslessStringCodable.Type
    
    public var value: T
    
    public init(from decoder: Decoder) throws {
        do {
            self.value = try T.init(from: decoder)

IanKeen

public struct DecodingRoutine<T: Decodable> {
    let decode: (Decoder) throws -> T?
}

extension DecodingRoutine {
    public static func `default`(_ value: T) -> DecodingRoutine {
        return .init { _ in value }
    }
}

IanKeen

import Foundation

class DictionaryDecoder {
    init() { }
    
    func decode<T: Decodable>(_ type: T.Type, from data: [String: Any]) throws -> T {
        let decoder = _Decoder(codingPath: [], source: data)
        return try T(from: decoder)
    }
}

IanKeen

struct AnyCodingKey: CodingKey {
    var stringValue: String
    var intValue: Int?
    
    init?(intValue: Int) {
        self.intValue = intValue
        self.stringValue = "\(intValue)"
    }
    init?(stringValue: String) {
        self.intValue = nil

IanKeen

protocol CodablePrimitive { }

extension String: CodablePrimitive { }
extension Bool: CodablePrimitive { }
extension Double: CodablePrimitive { }
extension Float: CodablePrimitive { }
extension Int: CodablePrimitive { }
extension Int8: CodablePrimitive { }
extension Int16: CodablePrimitive { }
extension Int32: CodablePrimitive { }

IanKeen

struct WithSecret<T> {
    let secret: String
    let value: T
}

extension WithSecret: Decodable where T: Decodable {
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: AnyCodingKey.self)
        
        self.secret = try container.decode(String.self, forKey: "secret")

IanKeen

class DictionaryEncoder {
    init() { }
    
    func encode(_ value: Encodable) throws -> [String: Any] {
        let encoder = _Encoder(codingPath: [])
        try value.encode(to: encoder)
        
        guard let result = encoder.value as? [String: Any] else {
            throw EncodingError.invalidValue(encoder.value as Any, .init(codingPath: [], debugDescription: "Invalid root container"))
        }