Local time, from Combine to SwiftUI

import Foundation/// The weather somewhere, now — from Open-Meteo, a free weather service that needs no key./// `Sendable`: plain data, like a trip.struct Weather: Sendable {    let place: String           // where Open-Meteo found the city, such as "Vancouver, Canada"    let temperature: Double     // in °F    // the sky, as a WMO weather code: 0 is a clear sky, 3 overcast, 61 rain…    let code: Int    var timeZone: TimeZone? = nil   // the city's, when Open-Meteo knows it    /// Finds the city, then asks for the weather there: two requests, one after the other.    /// `nonisolated(nonsending)`: it runs on whatever actor calls it — the main actor, from the trip's    /// screen. It mostly waits, and waiting needs no other thread.    nonisolated(nonsending) static func now(in city: String) async throws -> Weather {        print("Asking Open-Meteo about \(city)")        let search = try await URLSession.shared.json(PlaceSearch.self,                                                      from: "https://geocoding-api.open-meteo.com/v1/search",                                                      query: ["name": city, "count": "1"])        guard let place = search.results?.first else {            throw WeatherError.noSuchPlace(city)        }        let forecast = try await URLSession.shared.json(Forecast.self,                                                        from: "https://api.open-meteo.com/v1/forecast",                                                        query: ["latitude": "\(place.latitude)",                                                                "longitude": "\(place.longitude)",                                                                "current": "temperature_2m,weather_code",                                                                "temperature_unit": "fahrenheit"])        return Weather(place: [place.name, place.country].compactMap { $0 }.joined(separator: ", "),                       temperature: forecast.current.temperature,                       code: forecast.current.weatherCode)                       code: forecast.current.weatherCode,                       timeZone: place.timezone.flatMap(TimeZone.init(identifier:)))    }    /// The code in words, with an SF Symbol to match.    var sky: (words: String, symbol: String) {        switch code {        case 0: ("Clear sky", "sun.max")        case 1: ("Mainly clear", "sun.min")        case 2: ("Partly cloudy", "cloud.sun")        case 3: ("Overcast", "cloud")        case 45, 48: ("Fog", "cloud.fog")        case 51...57: ("Drizzle", "cloud.drizzle")        case 61...67, 80...82: ("Rain", "cloud.rain")        case 71...77, 85, 86: ("Snow", "cloud.snow")        case 95...99: ("Thunderstorm", "cloud.bolt.rain")        default: ("Weather code \(code)", "questionmark.circle")        }    }}/// Open-Meteo's answer to a search for a place. When nothing is found, `results` is not there at all./// `Sendable`, like each answer here: plain data — and so is the type inside it.struct PlaceSearch: Decodable, Sendable {    let results: [Place]?    struct Place: Decodable, Sendable {        let name: String        let country: String?        // some places have none: Hong Kong, for one        let latitude: Double        let longitude: Double        let timezone: String?       // such as "America/Los_Angeles"    }}/// Open-Meteo's answer to a request for the weather now — as much of it as Trips reads. `Sendable`: plain data.struct Forecast: Decodable, Sendable {    let current: Current    struct Current: Decodable, Sendable {        let temperature: Double        let weatherCode: Int        enum CodingKeys: String, CodingKey {            case temperature = "temperature_2m"            case weatherCode = "weather_code"        }    }}/// What can go wrong that URLSession and JSONDecoder do not already describe. `Sendable` without a word:/// Swift asks it of every `Error`.enum WeatherError: LocalizedError {    case noSuchPlace(String)    var errorDescription: String? {        switch self {        case .noSuchPlace(let city): "Open-Meteo knows no place called \(city)."        }    }}extension URLSession {    /// Asks for JSON and decodes it. An answer other than 200 OK is an error too — URLSession does not think so.    /// `nonisolated(nonsending)`, like `now(in:)`: it runs on its caller's actor.    nonisolated(nonsending) func json<Answer: Decodable>(_ type: Answer.Type, from address: String, query: [String: String]) async throws -> Answer {        var components = URLComponents(string: address)!        components.queryItems = query.map { URLQueryItem(name: $0.key, value: $0.value) }        let (data, response) = try await self.data(from: components.url!)        guard (response as? HTTPURLResponse)?.statusCode == 200 else {            throw URLError(.badServerResponse)        }        return try JSONDecoder().decode(type, from: data)    }}

import Foundation

/// The weather somewhere, now — from Open-Meteo, a free weather service that needs no key.
/// `Sendable`: plain data, like a trip.
struct Weather: Sendable {
    let place: String           // where Open-Meteo found the city, such as "Vancouver, Canada"
    let temperature: Double     // in °F
    // the sky, as a WMO weather code: 0 is a clear sky, 3 overcast, 61 rain…
    let code: Int
    var timeZone: TimeZone? = nil   // the city's, when Open-Meteo knows it

    /// Finds the city, then asks for the weather there: two requests, one after the other.
    /// `nonisolated(nonsending)`: it runs on whatever actor calls it — the main actor, from the trip's
    /// screen. It mostly waits, and waiting needs no other thread.
    nonisolated(nonsending) static func now(in city: String) async throws -> Weather {
        print("Asking Open-Meteo about \(city)")
        let search = try await URLSession.shared.json(PlaceSearch.self,
                                                      from: "https://geocoding-api.open-meteo.com/v1/search",
                                                      query: ["name": city, "count": "1"])
        guard let place = search.results?.first else {
            throw WeatherError.noSuchPlace(city)
        }
        let forecast = try await URLSession.shared.json(Forecast.self,
                                                        from: "https://api.open-meteo.com/v1/forecast",
                                                        query: ["latitude": "\(place.latitude)",
                                                                "longitude": "\(place.longitude)",
                                                                "current": "temperature_2m,weather_code",
                                                                "temperature_unit": "fahrenheit"])
        return Weather(place: [place.name, place.country].compactMap { $0 }.joined(separator: ", "),
                       temperature: forecast.current.temperature,
                       code: forecast.current.weatherCode,
                       timeZone: place.timezone.flatMap(TimeZone.init(identifier:)))
    }

    /// The code in words, with an SF Symbol to match.
    var sky: (words: String, symbol: String) {
        switch code {
        case 0: ("Clear sky", "sun.max")
        case 1: ("Mainly clear", "sun.min")
        case 2: ("Partly cloudy", "cloud.sun")
        case 3: ("Overcast", "cloud")
        case 45, 48: ("Fog", "cloud.fog")
        case 51...57: ("Drizzle", "cloud.drizzle")
        case 61...67, 80...82: ("Rain", "cloud.rain")
        case 71...77, 85, 86: ("Snow", "cloud.snow")
        case 95...99: ("Thunderstorm", "cloud.bolt.rain")
        default: ("Weather code \(code)", "questionmark.circle")
        }
    }
}

/// Open-Meteo's answer to a search for a place. When nothing is found, `results` is not there at all.
/// `Sendable`, like each answer here: plain data — and so is the type inside it.
struct PlaceSearch: Decodable, Sendable {
    let results: [Place]?

    struct Place: Decodable, Sendable {
        let name: String
        let country: String?        // some places have none: Hong Kong, for one
        let latitude: Double
        let longitude: Double
        let timezone: String?       // such as "America/Los_Angeles"
    }
}

/// Open-Meteo's answer to a request for the weather now — as much of it as Trips reads. `Sendable`: plain data.
struct Forecast: Decodable, Sendable {
    let current: Current

    struct Current: Decodable, Sendable {
        let temperature: Double
        let weatherCode: Int

        enum CodingKeys: String, CodingKey {
            case temperature = "temperature_2m"
            case weatherCode = "weather_code"
        }
    }
}

/// What can go wrong that URLSession and JSONDecoder do not already describe. `Sendable` without a word:
/// Swift asks it of every `Error`.
enum WeatherError: LocalizedError {
    case noSuchPlace(String)

    var errorDescription: String? {
        switch self {
        case .noSuchPlace(let city): "Open-Meteo knows no place called \(city)."
        }
    }
}

extension URLSession {
    /// Asks for JSON and decodes it. An answer other than 200 OK is an error too — URLSession does not think so.
    /// `nonisolated(nonsending)`, like `now(in:)`: it runs on its caller's actor.
    nonisolated(nonsending) func json<Answer: Decodable>(_ type: Answer.Type, from address: String, query: [String: String]) async throws -> Answer {
        var components = URLComponents(string: address)!
        components.queryItems = query.map { URLQueryItem(name: $0.key, value: $0.value) }
        let (data, response) = try await self.data(from: components.url!)
        guard (response as? HTTPURLResponse)?.statusCode == 200 else {
            throw URLError(.badServerResponse)
        }
        return try JSONDecoder().decode(type, from: data)
    }
}

import SwiftUI
import Combine

/// The time now, refreshed every second — written the way SwiftUI code was written before Observation.
/// `@MainActor`: the screen reads it, and the timer ticks on the main run loop.
@MainActor
final class Clock: ObservableObject {
    @Published private(set) var now = Date.now
    private var ticking: AnyCancellable?

    init() {
        ticking = Timer.publish(every: 1, on: .main, in: .common)
            .autoconnect()
            .sink { [weak self] date in
                self?.now = date
            }
    }
}

/// The time in a trip's city, as its weather card shows it.
struct LocalTime: View {
    let timeZone: TimeZone
    @StateObject private var clock = Clock()

    var body: some View {
        Label("Local time \(clock.now.formatted(Date.FormatStyle(date: .omitted, time: .standard, timeZone: timeZone)))",
              systemImage: "clock")
    }
}

import SwiftUI/// The weather on a trip's screen, in each of its three phases.struct WeatherView: View {    let phase: WeatherModel.Phase    var retry: () -> Void = {}    var body: some View {        Group {            switch phase {            case .loading:                ProgressView("Asking about the weather…")            case .loaded(let weather):                Label("\(weather.place): \(weather.temperature, format: .number.precision(.fractionLength(0)))°F, \(weather.sky.words)",                      systemImage: weather.sky.symbol)                VStack(spacing: 6) {                    Label("\(weather.place): \(weather.temperature, format: .number.precision(.fractionLength(0)))°F, \(weather.sky.words)",                          systemImage: weather.sky.symbol)                    if let timeZone = weather.timeZone {                        LocalTime(timeZone: timeZone)                            .font(.subheadline)                            .foregroundStyle(.secondary)                    }                }            case .failed(let reason):                VStack(spacing: 8) {                    Label(reason, systemImage: "exclamationmark.triangle")                    Button("Retry", action: retry)                        .buttonStyle(.bordered)                }            }        }        .frame(maxWidth: .infinity, minHeight: 44)        .padding()        .background(.thinMaterial, in: .rect(cornerRadius: 16))        .padding(.horizontal)    }}#Preview("Loading") {    WeatherView(phase: .loading)}#Preview("Loaded") {    WeatherView(phase: .loaded(Weather(place: "Seattle, United States", temperature: 61, code: 2)))}#Preview("Failed") {    WeatherView(phase: .failed(WeatherError.noSuchPlace("Hogsmeade").localizedDescription))}

import SwiftUI

/// The weather on a trip's screen, in each of its three phases.
struct WeatherView: View {
    let phase: WeatherModel.Phase
    var retry: () -> Void = {}

    var body: some View {
        Group {
            switch phase {
            case .loading:
                ProgressView("Asking about the weather…")
            case .loaded(let weather):
                VStack(spacing: 6) {
                    Label("\(weather.place): \(weather.temperature, format: .number.precision(.fractionLength(0)))°F, \(weather.sky.words)",
                          systemImage: weather.sky.symbol)
                    if let timeZone = weather.timeZone {
                        LocalTime(timeZone: timeZone)
                            .font(.subheadline)
                            .foregroundStyle(.secondary)
                    }
                }
            case .failed(let reason):
                VStack(spacing: 8) {
                    Label(reason, systemImage: "exclamationmark.triangle")
                    Button("Retry", action: retry)
                        .buttonStyle(.bordered)
                }
            }
        }
        .frame(maxWidth: .infinity, minHeight: 44)
        .padding()
        .background(.thinMaterial, in: .rect(cornerRadius: 16))
        .padding(.horizontal)
    }
}

#Preview("Loading") {
    WeatherView(phase: .loading)
}

#Preview("Loaded") {
    WeatherView(phase: .loaded(Weather(place: "Seattle, United States", temperature: 61, code: 2)))
}

#Preview("Failed") {
    WeatherView(phase: .failed(WeatherError.noSuchPlace("Hogsmeade").localizedDescription))
}

/// The time now, refreshed every second — written the way SwiftUI code was written before Observation./// `@MainActor`: the screen reads it, and the timer ticks on the main run loop./// The time now, refreshed every second — Observation outside, Combine still inside./// `@MainActor`, as before: the screen reads it.@MainActorfinal class Clock: ObservableObject {    @Published private(set) var now = Date.now    private var ticking: AnyCancellable?@Observablefinal class Clock {    private(set) var now = Date.now    @ObservationIgnored private var ticking: AnyCancellable?    init() {        ticking = Timer.publish(every: 1, on: .main, in: .common)            .autoconnect()            .sink { [weak self] date in                self?.now = date            }    }}

/// The time now, refreshed every second — Observation outside, Combine still inside.
/// `@MainActor`, as before: the screen reads it.
@MainActor
@Observable
final class Clock {
    private(set) var now = Date.now
    @ObservationIgnored private var ticking: AnyCancellable?

    init() {
        ticking = Timer.publish(every: 1, on: .main, in: .common)
            .autoconnect()
            .sink { [weak self] date in
                self?.now = date
            }
    }
}

/// The time in a trip's city, as its weather card shows it.struct LocalTime: View {    let timeZone: TimeZone    @StateObject private var clock = Clock()    @State private var clock = Clock()    var body: some View {        Label("Local time \(clock.now.formatted(Date.FormatStyle(date: .omitted, time: .standard, timeZone: timeZone)))",              systemImage: "clock")    }}

/// The time in a trip's city, as its weather card shows it.
struct LocalTime: View {
    let timeZone: TimeZone
    @State private var clock = Clock()

    var body: some View {
        Label("Local time \(clock.now.formatted(Date.FormatStyle(date: .omitted, time: .standard, timeZone: timeZone)))",
              systemImage: "clock")
    }
}

/// The time now, refreshed every second — Observation outside, Combine still inside./// `@MainActor`, as before: the screen reads it.@MainActor@Observablefinal class Clock {    private(set) var now = Date.now    @ObservationIgnored private var ticking: AnyCancellable?    init() {        ticking = Timer.publish(every: 1, on: .main, in: .common)            .autoconnect()            .sink { [weak self] date in                self?.now = date            }    }}

/// The time in a trip's city, as its weather card shows it./// The time in a trip's city, as its weather card shows it. SwiftUI redraws it every second.struct LocalTime: View {    let timeZone: TimeZone    @State private var clock = Clock()    var body: some View {        Label("Local time \(clock.now.formatted(Date.FormatStyle(date: .omitted, time: .standard, timeZone: timeZone)))",              systemImage: "clock")        TimelineView(.periodic(from: .now, by: 1)) { context in            Label("Local time \(context.date.formatted(Date.FormatStyle(date: .omitted, time: .standard, timeZone: timeZone)))",                  systemImage: "clock")        }    }}

/// The time in a trip's city, as its weather card shows it. SwiftUI redraws it every second.
struct LocalTime: View {
    let timeZone: TimeZone

    var body: some View {
        TimelineView(.periodic(from: .now, by: 1)) { context in
            Label("Local time \(context.date.formatted(Date.FormatStyle(date: .omitted, time: .standard, timeZone: timeZone)))",
                  systemImage: "clock")
        }
    }
}

import SwiftUIimport Combine

import SwiftUI