1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
import Foundation
@Observable
@MainActor
final class ContributionCalendarViewModel {
enum DisplayState: Equatable {
case populated
case indexing
case empty
case unavailable
}
private(set) var calendar: ContributionCalendarResponse?
private(set) var stats: ContributionStatsResponse?
private(set) var isLoading = false
var loadErrorMessage: String?
var selectedEndDate: Date
let actor: String
private let service: any ContributionCalendarServing
private let currentEndDate: Date
init(
actor: String,
service: any ContributionCalendarServing,
selectedEndDate: Date? = nil
) {
self.actor = actor
self.service = service
let today = Calendar.contributionCalendar.startOfDay(for: Date())
let resolvedEndDate = Calendar.contributionCalendar.startOfDay(for: selectedEndDate ?? today)
self.selectedEndDate = resolvedEndDate
self.currentEndDate = today
}
var weekColumns: [ContributionWeek] {
ContributionCalendarLayout.weekColumns(from: calendar?.days ?? [])
}
var recentWeekColumns: [ContributionWeek] {
ContributionCalendarLayout.recentWeeks(from: calendar?.days ?? [], count: 8)
}
var isEmpty: Bool {
calendar?.isEmpty ?? false
}
var isIndexedButEmpty: Bool {
displayState != .populated
&& displayState != .unavailable
&& ((stats?.totalEvents == 0) || (calendar?.isEmpty == true))
}
var displayState: DisplayState {
if hasActivity {
return .populated
}
switch effectiveIndexingState {
case .pending:
return .indexing
case .error:
return .unavailable
case .indexed:
return .empty
case nil:
return .empty
}
}
var emptyStateTitle: String {
switch displayState {
case .indexing:
"Indexing Activity"
case .empty:
"No Contribution Activity"
case .unavailable:
"Activity Unavailable"
case .populated:
""
}
}
var emptyStateMessage: String {
switch displayState {
case .indexing:
"This user’s SourceHut activity is being indexed. Check back soon."
case .empty:
"No activity was found for this time range."
case .unavailable:
"The contribution graph couldn’t be refreshed right now. Try again later."
case .populated:
""
}
}
var lastUpdatedText: String? {
guard let lastPolledAt = effectiveLastPolledAt else {
return nil
}
return "Updated \(lastPolledAt.formatted(date: .abbreviated, time: .shortened))"
}
var canAdvanceYear: Bool {
selectedEndDate < currentEndDate
}
var displayedRangeText: String {
let range = trailingRange
return "\(range.lowerBound.formatted(date: .abbreviated, time: .omitted)) to \(range.upperBound.formatted(date: .abbreviated, time: .omitted))"
}
func load() async {
isLoading = true
loadErrorMessage = nil
defer { isLoading = false }
let fetchedCalendar: ContributionCalendarResponse?
let fetchedStats: ContributionStatsResponse?
var errors: [any Error] = []
do {
fetchedCalendar = try await service.fetchContributionCalendar(actor: actor, endingOn: selectedEndDate)
} catch {
fetchedCalendar = nil
errors.append(error)
}
do {
fetchedStats = try await service.fetchContributionStats(actor: actor, endingOn: selectedEndDate)
} catch {
fetchedStats = nil
errors.append(error)
}
calendar = fetchedCalendar
stats = fetchedStats
if displayState != .unavailable {
loadErrorMessage = nil
} else if fetchedCalendar == nil && fetchedStats == nil {
loadErrorMessage = errors.first?.userFacingMessage
} else {
loadErrorMessage = errors.first?.userFacingMessage
}
}
func selectPreviousYear() async {
guard let previousEndDate = Calendar.contributionCalendar.date(byAdding: .year, value: -1, to: selectedEndDate) else {
return
}
selectedEndDate = previousEndDate
await load()
}
func selectNextYear() async {
guard canAdvanceYear else { return }
let advancedDate = Calendar.contributionCalendar.date(byAdding: .year, value: 1, to: selectedEndDate) ?? currentEndDate
selectedEndDate = min(advancedDate, currentEndDate)
await load()
}
private var hasActivity: Bool {
if let stats, stats.totalEvents > 0 {
return true
}
if let calendar, !calendar.isEmpty {
return true
}
return false
}
private var effectiveIndexingState: ContributionIndexingState? {
stats?.indexingState ?? calendar?.indexingState
}
private var effectiveLastPolledAt: Date? {
stats?.lastPolledAt ?? calendar?.lastPolledAt
}
private var trailingRange: ClosedRange<Date> {
let normalizedEndDate = Calendar.contributionCalendar.startOfDay(for: selectedEndDate)
let oneYearBack = Calendar.contributionCalendar.date(byAdding: .year, value: -1, to: normalizedEndDate) ?? normalizedEndDate
let normalizedStartDate = Calendar.contributionCalendar.date(byAdding: .day, value: 1, to: oneYearBack) ?? oneYearBack
return normalizedStartDate...normalizedEndDate
}
}
|
