Kod Snippet Kütüphanesi

extension String {
    var isValidEmail: Bool {
        let pattern = #"^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+.[A-Za-z]{2,}$"#
        return self.range(of: pattern, options: .regularExpression) != nil
    }

    var trimmed: String {
        trimmingCharacters(in: .whitespacesAndNewlines)
    }

    var isBlank: Bool {
        trimmed.isEmpty
    }

    func capitalizingFirstLetter() -> String {
        prefix(1).uppercased() + dropFirst()
    }
}

extension Collection {
    subscript(safe index: Index) -> Element? {
        indices.contains(index) ? self[index] : nil
    }
}

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

    func unique<T: Hashable>(by keyPath: KeyPath<Element, T>) -> [Element] {
        var seen = Set<T>()
        return filter { seen.insert($0[keyPath: keyPath]).inserted }
    }
}

extension Date {
    func formatted(_ format: String) -> String {
        let formatter = DateFormatter()
        formatter.dateFormat = format
        formatter.locale = Locale(identifier: "tr_TR")
        return formatter.string(from: self)
    }

    var isoString: String {
        ISO8601DateFormatter().string(from: self)
    }

    var isToday: Bool {
        Calendar.current.isDateInToday(self)
    }

    func adding(days: Int) -> Date {
        Calendar.current.date(byAdding: .day, value: days, to: self) ?? self
    }
}

extension String {
    func toDate(format: String) -> Date? {
        let formatter = DateFormatter()
        formatter.dateFormat = format
        return formatter.date(from: self)
    }
}

extension View {
    @ViewBuilder
    func `if`<Content: View>(
        _ condition: Bool,
        transform: (Self) -> Content
    ) -> some View {
        if condition {
            transform(self)
        } else {
            self
        }
    }

    @ViewBuilder
    func ifLet<Value, Content: View>(
        _ value: Value?,
        transform: (Self, Value) -> Content
    ) -> some View {
        if let value {
            transform(self, value)
        } else {
            self
        }
    }

    func hidden(_ isHidden: Bool) -> some View {
        opacity(isHidden ? 0 : 1)
    }
}

extension Color {
    init(hex: String) {
        let hex = hex.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
        var int: UInt64 = 0
        Scanner(string: hex).scanHexInt64(&int)
        let a, r, g, b: UInt64
        switch hex.count {
        case 3:
            (a, r, g, b) = (255, (int >> 8) * 17, (int >> 4 & 0xF) * 17, (int & 0xF) * 17)
        case 6:
            (a, r, g, b) = (255, int >> 16, int >> 8 & 0xFF, int & 0xFF)
        case 8:
            (a, r, g, b) = (int >> 24, int >> 16 & 0xFF, int >> 8 & 0xFF, int & 0xFF)
        default:
            (a, r, g, b) = (255, 0, 0, 0)
        }
        self.init(
            .sRGB,
            red: Double(r) / 255,
            green: Double(g) / 255,
            blue: Double(b) / 255,
            opacity: Double(a) / 255
        )
    }

    var hexString: String {
        let components = UIColor(self).cgColor.components ?? [0, 0, 0, 1]
        let r = Int(components[0] * 255)
        let g = Int(components[1] * 255)
        let b = Int(components[2] * 255)
        return String(format: "#%02X%02X%02X", r, g, b)
    }
}

@propertyWrapper
struct Stored<Value: Codable> {
    let key: String
    let defaultValue: Value
    let store: UserDefaults

    init(_ key: String, default defaultValue: Value, store: UserDefaults = .standard) {
        self.key = key
        self.defaultValue = defaultValue
        self.store = store
    }

    var wrappedValue: Value {
        get {
            guard let data = store.data(forKey: key),
                  let decoded = try? JSONDecoder().decode(Value.self, from: data)
            else { return defaultValue }
            return decoded
        }
        set {
            if let encoded = try? JSONEncoder().encode(newValue) {
                store.set(encoded, forKey: key)
            }
        }
    }

    var projectedValue: Binding<Value> {
        Binding(
            get: { wrappedValue },
            set: { wrappedValue = $0 }
        )
    }
}

import Combine
import UIKit

extension NotificationCenter {
    func publisher<T>(
        for name: Notification.Name,
        extracting keyPath: KeyPath<Notification, T?>
    ) -> AnyPublisher<T, Never> {
        publisher(for: name)
            .compactMap { $0[keyPath: keyPath] }
            .eraseToAnyPublisher()
    }
}

extension Publisher {
    func sink(receiveValue: @escaping (Output) -> Void) -> AnyCancellable {
        sink(receiveCompletion: { _ in }, receiveValue: receiveValue)
    }

    func withPrevious() -> AnyPublisher<(Output?, Output), Failure> {
        scan((Output?.none, Output?.none)) { ($0.1, $1) }
            .compactMap { prev, curr in
                guard let curr else { return nil }
                return (prev, curr)
            }
            .eraseToAnyPublisher()
    }
}

extension Result {
    var value: Success? {
        guard case .success(let v) = self else { return nil }
        return v
    }

    var error: Failure? {
        guard case .failure(let e) = self else { return nil }
        return e
    }

    var isSuccess: Bool { value != nil }

    func mapError<NewFailure: Error>(
        _ transform: (Failure) -> NewFailure
    ) -> Result<Success, NewFailure> {
        switch self {
        case .success(let v): return .success(v)
        case .failure(let e): return .failure(transform(e))
        }
    }

    func recover(_ transform: (Failure) -> Success) -> Success {
        switch self {
        case .success(let v): return v
        case .failure(let e): return transform(e)
        }
    }
}

enum HTTPMethod: String {
    case get = "GET", post = "POST", put = "PUT", delete = "DELETE"
}

struct APIClient {
    private let session: URLSession
    private let decoder: JSONDecoder
    private let baseURL: URL

    init(baseURL: URL, session: URLSession = .shared) {
        self.baseURL = baseURL
        self.session = session
        self.decoder = JSONDecoder()
        self.decoder.keyDecodingStrategy = .convertFromSnakeCase
        self.decoder.dateDecodingStrategy = .iso8601
    }

    func request<T: Decodable>(
        path: String,
        method: HTTPMethod = .get,
        body: (some Encodable)? = nil as Int?,
        headers: [String: String] = [:]
    ) async throws -> T {
        var urlRequest = URLRequest(url: baseURL.appendingPathComponent(path))
        urlRequest.httpMethod = method.rawValue
        urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
        headers.forEach { urlRequest.setValue($1, forHTTPHeaderField: $0) }

        if let body {
            urlRequest.httpBody = try JSONEncoder().encode(body)
        }

        let (data, response) = try await session.data(for: urlRequest)

        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).contains(httpResponse.statusCode) else {
            throw URLError(.badServerResponse)
        }

        return try decoder.decode(T.self, from: data)
    }
}

struct RetryPolicy {
    let maxAttempts: Int
    let baseDelay: TimeInterval
    let multiplier: Double

    static let `default` = RetryPolicy(maxAttempts: 3, baseDelay: 0.5, multiplier: 2.0)
    static let aggressive = RetryPolicy(maxAttempts: 5, baseDelay: 0.2, multiplier: 1.5)

    func delay(for attempt: Int) -> TimeInterval {
        baseDelay * pow(multiplier, Double(attempt))
    }
}

extension URLSession {
    func dataWithRetry(
        for request: URLRequest,
        policy: RetryPolicy = .default
    ) async throws -> (Data, URLResponse) {
        var lastError: Error?
        for attempt in 0..<policy.maxAttempts {
            do {
                return try await data(for: request)
            } catch {
                lastError = error
                guard attempt < policy.maxAttempts - 1 else { break }
                try await Task.sleep(nanoseconds: UInt64(policy.delay(for: attempt) * 1_000_000_000))
            }
        }
        throw lastError ?? URLError(.unknown)
    }
}

struct MultipartFormData {
    private let boundary = UUID().uuidString
    private var body = Data()

    var contentType: String {
        "multipart/form-data; boundary=(boundary)"
    }

    mutating func addTextField(name: String, value: String) {
        body.append("--(boundary)
".data(using: .utf8)!)
        body.append("Content-Disposition: form-data; name="(name)"

".data(using: .utf8)!)
        body.append("(value)
".data(using: .utf8)!)
    }

    mutating func addDataField(name: String, data: Data, filename: String, mimeType: String) {
        body.append("--(boundary)
".data(using: .utf8)!)
        body.append("Content-Disposition: form-data; name="(name)"; filename="(filename)"
".data(using: .utf8)!)
        body.append("Content-Type: (mimeType)

".data(using: .utf8)!)
        body.append(data)
        body.append("
".data(using: .utf8)!)
    }

    func build() -> Data {
        var result = body
        result.append("--(boundary)--
".data(using: .utf8)!)
        return result
    }
}

@MainActor
final class WebSocketClient: ObservableObject {
    @Published var messages: [String] = []
    @Published var isConnected = false

    private var task: URLSessionWebSocketTask?
    private let url: URL

    init(url: URL) { self.url = url }

    func connect() {
        let session = URLSession(configuration: .default)
        task = session.webSocketTask(with: url)
        task?.resume()
        isConnected = true
        startReceiving()
        schedulePing()
    }

    func send(_ message: String) async throws {
        try await task?.send(.string(message))
    }

    func disconnect() {
        task?.cancel(with: .goingAway, reason: nil)
        isConnected = false
    }

    private func startReceiving() {
        task?.receive { [weak self] result in
            switch result {
            case .success(.string(let text)):
                Task { @MainActor in self?.messages.append(text) }
                self?.startReceiving()
            case .failure:
                Task { @MainActor in self?.isConnected = false }
            default: break
            }
        }
    }

    private func schedulePing() {
        Task {
            while isConnected {
                try? await Task.sleep(nanoseconds: 30_000_000_000)
                task?.sendPing { _ in }
            }
        }
    }
}