Scarriffle
d5a9dad769
Signing out deletes the cached events — keeping them would leak the previous user's calendar to anything reading the container — so an absent cache alone cannot distinguish "signed out" from "Calendarr has never run on this machine". Those need different messages, so read() now falls back to the session record and reports .loggedOut when one exists and says so. Every consumer would otherwise have to reimplement that two-step, and any that forgot would tell a signed-out user to go install an app they already have. SnapshotTheme only had the compiler's internal memberwise initializer, so no consumer outside the package could actually build one.
224 lines
9.5 KiB
Swift
224 lines
9.5 KiB
Swift
import Foundation
|
||
|
||
// MARK: - Coverage policy
|
||
|
||
/// How much of the calendar the writer publishes. Shared so the writer and the
|
||
/// v1-file reconstruction below can never disagree about it.
|
||
public enum SnapshotCoverage {
|
||
/// Days before today. The current week must stay complete for widgets that
|
||
/// render Monday–today.
|
||
public static let daysBehind = 7
|
||
/// Days after today.
|
||
public static let daysAhead = 42
|
||
/// Hard cap on events written, applied after sorting by start date.
|
||
public static let maxEvents = 500
|
||
}
|
||
|
||
// MARK: - Event
|
||
|
||
/// One event as published to the shared container.
|
||
///
|
||
/// Deliberately lossy: notes, URL, source, creator, privacy, read-only status,
|
||
/// reminders and recurrence rules are all dropped. This is enough to *display* a
|
||
/// calendar and deliberately not enough to edit one or reason about permissions.
|
||
public struct SnapshotEvent: Codable, Sendable, Identifiable, Hashable {
|
||
public let id: String
|
||
public let title: String
|
||
public let start: Date
|
||
public let end: Date
|
||
public let isAllDay: Bool
|
||
public let colorHex: String
|
||
public let location: String
|
||
/// Ties the event to a calendar. See `CalendarKey`.
|
||
public let calendarKey: String
|
||
|
||
public init(id: String, title: String, start: Date, end: Date,
|
||
isAllDay: Bool, colorHex: String, location: String, calendarKey: String) {
|
||
self.id = id; self.title = title; self.start = start; self.end = end
|
||
self.isAllDay = isAllDay; self.colorHex = colorHex
|
||
self.location = location; self.calendarKey = calendarKey
|
||
}
|
||
|
||
// Lenient: caches written before calendarKey existed simply lack the field.
|
||
public init(from decoder: Decoder) throws {
|
||
let c = try decoder.container(keyedBy: CodingKeys.self)
|
||
id = try c.decode(String.self, forKey: .id)
|
||
title = try c.decode(String.self, forKey: .title)
|
||
start = try c.decode(Date.self, forKey: .start)
|
||
end = try c.decode(Date.self, forKey: .end)
|
||
isAllDay = try c.decode(Bool.self, forKey: .isAllDay)
|
||
colorHex = try c.decode(String.self, forKey: .colorHex)
|
||
location = try c.decode(String.self, forKey: .location)
|
||
calendarKey = try c.decodeIfPresent(String.self, forKey: .calendarKey) ?? ""
|
||
}
|
||
}
|
||
|
||
// MARK: - Calendar
|
||
|
||
/// A calendar available for filtering, published alongside the events so a
|
||
/// consumer can build a picker without a network call.
|
||
public struct SnapshotCalendar: Codable, Sendable, Identifiable, Hashable {
|
||
/// A `CalendarKey`, matching `SnapshotEvent.calendarKey`.
|
||
public let id: String
|
||
public let name: String
|
||
public let colorHex: String
|
||
|
||
public init(id: String, name: String, colorHex: String) {
|
||
self.id = id; self.name = name; self.colorHex = colorHex
|
||
}
|
||
}
|
||
|
||
// MARK: - Theme
|
||
|
||
/// The colours the app is currently rendering with, so a consumer can match it
|
||
/// without reading the app's own preferences.
|
||
public struct SnapshotTheme: Sendable, Hashable {
|
||
public let today: String
|
||
public let text: String
|
||
public let background: String
|
||
public let line: String
|
||
public let primary: String
|
||
public let accent: String
|
||
|
||
public init(today: String, text: String, background: String,
|
||
line: String, primary: String, accent: String) {
|
||
self.today = today; self.text = text; self.background = background
|
||
self.line = line; self.primary = primary; self.accent = accent
|
||
}
|
||
}
|
||
|
||
// MARK: - Snapshot
|
||
|
||
/// The published calendar snapshot.
|
||
///
|
||
/// ## Wire compatibility
|
||
///
|
||
/// The six colour values are stored **flat** at the top level rather than nested
|
||
/// under `theme`, even though `theme` is the nicer thing to read in code. That is
|
||
/// deliberate: v1 files carry them flat and a v1 reader requires them flat, so
|
||
/// nesting would break older readers on the very first v2 write. Within a major
|
||
/// version this format only ever gains optional fields — old readers ignore what
|
||
/// they do not know, new readers default what is missing. `theme` is a computed
|
||
/// view over the stored values, so callers get the clean shape anyway.
|
||
public struct CalendarrSnapshot: Codable, Sendable {
|
||
/// Bump only for a breaking change, and see the rules in the README.
|
||
public static let currentSchema = 2
|
||
/// Files claiming a higher schema are refused rather than mis-decoded.
|
||
public static let maxSupportedSchema = 2
|
||
|
||
public let schemaVersion: Int
|
||
public let writtenAt: Date
|
||
/// Start of the published window. Outside `coverageStart..<coverageEnd` the
|
||
/// snapshot carries *no information* — which is not the same as "no events".
|
||
public let coverageStart: Date
|
||
public let coverageEnd: Date
|
||
/// False once the user signs out. Distinguishes "signed out" from "never ran".
|
||
public let isLoggedIn: Bool
|
||
/// CFBundleShortVersionString of whoever wrote the file. Diagnostics only.
|
||
public let writerVersion: String
|
||
public let events: [SnapshotEvent]
|
||
public let language: String
|
||
|
||
// Stored flat for wire compatibility — read them via `theme`.
|
||
let todayColorHex: String
|
||
let textColorHex: String
|
||
let backgroundColorHex: String
|
||
let lineColorHex: String
|
||
let primaryColorHex: String
|
||
let accentColorHex: String
|
||
|
||
public var theme: SnapshotTheme {
|
||
SnapshotTheme(today: todayColorHex, text: textColorHex,
|
||
background: backgroundColorHex, line: lineColorHex,
|
||
primary: primaryColorHex, accent: accentColorHex)
|
||
}
|
||
|
||
/// True when `date` falls inside the published window, i.e. when an absence
|
||
/// of events for that date genuinely means "nothing scheduled".
|
||
public func covers(_ date: Date) -> Bool {
|
||
date >= coverageStart && date < coverageEnd
|
||
}
|
||
|
||
public init(writtenAt: Date,
|
||
coverageStart: Date,
|
||
coverageEnd: Date,
|
||
isLoggedIn: Bool,
|
||
writerVersion: String,
|
||
events: [SnapshotEvent],
|
||
theme: SnapshotTheme,
|
||
language: String) {
|
||
self.schemaVersion = Self.currentSchema
|
||
self.writtenAt = writtenAt
|
||
self.coverageStart = coverageStart
|
||
self.coverageEnd = coverageEnd
|
||
self.isLoggedIn = isLoggedIn
|
||
self.writerVersion = writerVersion
|
||
self.events = events
|
||
self.language = language
|
||
self.todayColorHex = theme.today
|
||
self.textColorHex = theme.text
|
||
self.backgroundColorHex = theme.background
|
||
self.lineColorHex = theme.line
|
||
self.primaryColorHex = theme.primary
|
||
self.accentColorHex = theme.accent
|
||
}
|
||
|
||
/// Lenient decoder. Everything added after v1 is optional here, and a v1
|
||
/// file's coverage window is reconstructed from the policy that produced it.
|
||
public init(from decoder: Decoder) throws {
|
||
let c = try decoder.container(keyedBy: CodingKeys.self)
|
||
schemaVersion = try c.decodeIfPresent(Int.self, forKey: .schemaVersion) ?? 1
|
||
writtenAt = try c.decode(Date.self, forKey: .writtenAt)
|
||
events = try c.decode([SnapshotEvent].self, forKey: .events)
|
||
language = try c.decode(String.self, forKey: .language)
|
||
|
||
todayColorHex = try c.decode(String.self, forKey: .todayColorHex)
|
||
textColorHex = try c.decode(String.self, forKey: .textColorHex)
|
||
backgroundColorHex = try c.decode(String.self, forKey: .backgroundColorHex)
|
||
lineColorHex = try c.decode(String.self, forKey: .lineColorHex)
|
||
primaryColorHex = try c.decodeIfPresent(String.self, forKey: .primaryColorHex) ?? "#4285f4"
|
||
accentColorHex = try c.decodeIfPresent(String.self, forKey: .accentColorHex) ?? "#ea4335"
|
||
|
||
isLoggedIn = try c.decodeIfPresent(Bool.self, forKey: .isLoggedIn) ?? true
|
||
writerVersion = try c.decodeIfPresent(String.self, forKey: .writerVersion) ?? "unknown"
|
||
|
||
// v1 had no explicit window; it always wrote the same one, measured from
|
||
// the start of the day it was written.
|
||
let cal = Calendar(identifier: .gregorian)
|
||
let dayStart = cal.startOfDay(for: writtenAt)
|
||
coverageStart = try c.decodeIfPresent(Date.self, forKey: .coverageStart)
|
||
?? cal.date(byAdding: .day, value: -SnapshotCoverage.daysBehind, to: dayStart) ?? dayStart
|
||
coverageEnd = try c.decodeIfPresent(Date.self, forKey: .coverageEnd)
|
||
?? cal.date(byAdding: .day, value: SnapshotCoverage.daysAhead, to: dayStart) ?? dayStart
|
||
}
|
||
|
||
enum CodingKeys: String, CodingKey {
|
||
case schemaVersion, writtenAt, coverageStart, coverageEnd, isLoggedIn, writerVersion
|
||
case events, language
|
||
case todayColorHex, textColorHex, backgroundColorHex, lineColorHex
|
||
case primaryColorHex, accentColorHex
|
||
}
|
||
}
|
||
|
||
// MARK: - Read result
|
||
|
||
/// Why a read produced no usable snapshot. The distinction matters for the UI:
|
||
/// "never ran", "signed out" and "genuinely empty" call for different messages.
|
||
public enum SnapshotReadResult: Sendable {
|
||
case ok(CalendarrSnapshot)
|
||
/// The user signed out of Calendarr. Show a sign-in prompt, not stale events.
|
||
case loggedOut(writtenAt: Date)
|
||
/// Calendarr has never published on this machine. Ask the user to open it once.
|
||
case neverWritten
|
||
/// Written by a newer Calendarr than this reader understands. Refuse rather
|
||
/// than guess; ask the user to update.
|
||
case incompatible(foundSchema: Int, maxSupported: Int)
|
||
/// Corrupt file, or — much more likely — a misconfigured App Group.
|
||
case unreadable(String)
|
||
|
||
public var snapshot: CalendarrSnapshot? {
|
||
if case .ok(let s) = self { return s }
|
||
return nil
|
||
}
|
||
}
|