From 5e4e259d8bfd9b062aa39af793ec3a59b70ad7f0 Mon Sep 17 00:00:00 2001 From: Christian Cleberg Date: Fri, 7 Aug 2026 01:44:10 -0500 Subject: Fix checklist rendering with inline code (#18) The .task-list-item CSS used display: inline-flex, which turned each text run and inline into separate rigid flex items so a bullet mixing code with text rendered malformed instead of flowing inline. The checkbox is already centered via vertical-align, so switch to plain inline display and let the fragments flow and wrap naturally. --- Hutch/Views/Repositories/ReadmeView.swift | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) (limited to 'Hutch/Views') diff --git a/Hutch/Views/Repositories/ReadmeView.swift b/Hutch/Views/Repositories/ReadmeView.swift index 69d105b..b8b9622 100644 --- a/Hutch/Views/Repositories/ReadmeView.swift +++ b/Hutch/Views/Repositories/ReadmeView.swift @@ -1809,9 +1809,7 @@ private struct HTMLWebViewRepresentable: UIViewRepresentable { vertical-align: middle; } .task-list-item { - display: inline-flex; - align-items: center; - gap: 0.1rem; + display: inline; } a { color: \(linkColor); } table { border-collapse: collapse; width: 100%; } -- cgit v1.2.3 From a0ed11a3c4ddb2f532fa70884dc2829a23a5eec8 Mon Sep 17 00:00:00 2001 From: Christian Cleberg Date: Fri, 7 Aug 2026 01:44:17 -0500 Subject: Let users clear recent activity on Home (#11) Add a Clear button in the Home Recent section header to drop all entries, plus swipe-to-delete on each row to forget a single item (gated on the existing swipe-actions setting). Back it with RecentActivityStore.clear and remove(id:), with unit tests. --- Hutch/Views/Home/HomeView.swift | 33 +++++++++++++++++++++++++- Hutch/Views/Home/RecentActivityStore.swift | 10 ++++++++ HutchTests/RecentActivityStoreTests.swift | 38 ++++++++++++++++++++++++++++++ 3 files changed, 80 insertions(+), 1 deletion(-) create mode 100644 HutchTests/RecentActivityStoreTests.swift (limited to 'Hutch/Views') diff --git a/Hutch/Views/Home/HomeView.swift b/Hutch/Views/Home/HomeView.swift index f0ec9ff..0e3e214 100644 --- a/Hutch/Views/Home/HomeView.swift +++ b/Hutch/Views/Home/HomeView.swift @@ -5,6 +5,8 @@ struct HomeView: View { @Environment(\.scenePhase) private var scenePhase @AppStorage(AppStorageKeys.homeFailedBuildLookbackDays, store: .standard) private var failedBuildLookbackDays = HomeViewModel.defaultFailedBuildLookbackDays + @AppStorage(AppStorageKeys.swipeActionsEnabled, store: .standard) + private var swipeActionsEnabled = true @State private var viewModel: HomeViewModel? @State private var recentItems: [RecentActivityEntry] = [] @State private var isOpeningRecentItem = false @@ -118,7 +120,7 @@ struct HomeView: View { @ViewBuilder private var recentSection: some View { if !recentItems.isEmpty { - Section("Recent") { + Section { ForEach(recentItems.prefix(3)) { item in Button { openRecentItem(item) @@ -128,12 +130,41 @@ struct HomeView: View { .buttonStyle(.plain) .disabled(isOpeningRecentItem) .listRowSeparator(.hidden) + .swipeActions(edge: .trailing, allowsFullSwipe: true) { + if swipeActionsEnabled { + Button(role: .destructive) { + removeRecentItem(item) + } label: { + Label("Remove", systemImage: "trash") + } + } + } } .themedRow() + } header: { + HStack { + Text("Recent") + Spacer() + Button("Clear") { + clearRecentActivity() + } + .font(.caption) + .textCase(nil) + } } } } + private func removeRecentItem(_ item: RecentActivityEntry) { + RecentActivityStore.remove(id: item.id, defaults: appState.accountDefaults) + loadRecentActivity() + } + + private func clearRecentActivity() { + RecentActivityStore.clear(defaults: appState.accountDefaults) + loadRecentActivity() + } + private func buildsSection(_ viewModel: HomeViewModel) -> some View { Section("Builds") { Button { diff --git a/Hutch/Views/Home/RecentActivityStore.swift b/Hutch/Views/Home/RecentActivityStore.swift index 464a2c1..6bc5720 100644 --- a/Hutch/Views/Home/RecentActivityStore.swift +++ b/Hutch/Views/Home/RecentActivityStore.swift @@ -129,6 +129,16 @@ enum RecentActivityStore { ) } + static func remove(id: String, defaults: UserDefaults) { + var entries = load(defaults: defaults) + entries.removeAll { $0.id == id } + save(entries, defaults: defaults) + } + + static func clear(defaults: UserDefaults) { + defaults.removeObject(forKey: AppStorageKeys.recentActivity) + } + private static func record(_ entry: RecentActivityEntry, defaults: UserDefaults) { var entries = load(defaults: defaults) entries.removeAll { $0.id == entry.id } diff --git a/HutchTests/RecentActivityStoreTests.swift b/HutchTests/RecentActivityStoreTests.swift new file mode 100644 index 0000000..e6fcc04 --- /dev/null +++ b/HutchTests/RecentActivityStoreTests.swift @@ -0,0 +1,38 @@ +import Foundation +import Testing +@testable import Hutch + +struct RecentActivityStoreTests { + @Test + func removeDropsMatchingEntryKeepingOthers() { + let defaults = UserDefaults(suiteName: #function)! + defaults.removePersistentDomain(forName: #function) + + RecentActivityStore.recordBuild(jobId: 1, title: "Build 1", defaults: defaults) + RecentActivityStore.recordBuild(jobId: 2, title: "Build 2", defaults: defaults) + + RecentActivityStore.remove(id: "build:1", defaults: defaults) + + let remaining = RecentActivityStore.load(defaults: defaults) + #expect(remaining.map(\.id) == ["build:2"]) + } + + @Test + func clearRemovesAllEntries() { + let defaults = UserDefaults(suiteName: #function)! + defaults.removePersistentDomain(forName: #function) + + RecentActivityStore.recordBuild(jobId: 1, title: "Build 1", defaults: defaults) + RecentActivityStore.recordTicket( + ownerUsername: "~alice", + trackerName: "hutch", + ticketId: 42, + title: "A ticket", + defaults: defaults + ) + + RecentActivityStore.clear(defaults: defaults) + + #expect(RecentActivityStore.load(defaults: defaults).isEmpty) + } +} -- cgit v1.2.3 From 1c4e968c31ee451666a65e05c762c9422c768426 Mon Sep 17 00:00:00 2001 From: Christian Cleberg Date: Fri, 7 Aug 2026 01:44:26 -0500 Subject: Take inbox unread count off pull-to-refresh path (#9) The inbox count paginates every thread of every subscribed list (~25s), and .refreshable binds the spinner to loadDashboard returning, so pull held for the whole time. Refresh the count in a cancellable background task that updates the badge when it lands, so pull returns once the fast branches settle. The widget / App Intents snapshot refresh, which builds from a throwaway view model, opts back into awaiting inbox so its count stays accurate. --- Hutch/App/AppState.swift | 2 +- Hutch/Views/Home/HomeViewModel.swift | 51 +++++++++++++++++++++++++++++++----- 2 files changed, 46 insertions(+), 7 deletions(-) (limited to 'Hutch/Views') diff --git a/Hutch/App/AppState.swift b/Hutch/App/AppState.swift index ad31c5c..a526afd 100644 --- a/Hutch/App/AppState.swift +++ b/Hutch/App/AppState.swift @@ -623,7 +623,7 @@ final class AppState { defaults: accountDefaults, accountID: activeAccountID ) - await viewModel.loadDashboard() + await viewModel.loadDashboard(awaitInboxUnread: true) } private func clearWebData() async { diff --git a/Hutch/Views/Home/HomeViewModel.swift b/Hutch/Views/Home/HomeViewModel.swift index 7779bea..23b2d80 100644 --- a/Hutch/Views/Home/HomeViewModel.swift +++ b/Hutch/Views/Home/HomeViewModel.swift @@ -199,6 +199,7 @@ final class HomeViewModel { private let projectService: ProjectService private let ticketFetchConcurrencyLimit = 6 private let inboxUnreadConcurrencyLimit = 4 + private var inboxRefreshTask: Task? private var currentUserKey: String { currentUser.canonicalName @@ -348,7 +349,19 @@ final class HomeViewModel { /// `forceRefresh` bypasses the cache. Without it, a pull to refresh returns /// whatever is already cached and only schedules a background fetch, so new /// mail cannot show up on the first pull. - func loadDashboard(forceRefresh: Bool = false) async { + /// + /// The inbox unread count is deliberately kept off this method's critical + /// path: it paginates every thread of every subscribed list and costs + /// ~25s, which — because `.refreshable` binds the spinner to this method + /// returning — would hold the pull-to-refresh spinner for the whole time. + /// Instead it refreshes in a detached background task and updates the badge + /// when it lands, so the spinner returns as soon as the fast branches settle. + /// + /// Callers that build a persisted snapshot from a throwaway view model — + /// the widget / App Intents needs-attention refresh — cannot let the inbox + /// fetch outlive them, so they pass `awaitInboxUnread: true` to fold it back + /// onto the critical path and get an accurate count before this returns. + func loadDashboard(forceRefresh: Bool = false, awaitInboxUnread: Bool = false) async { isLoadingProjects = true isLoadingAssignedTickets = true isLoadingRecentBuilds = true @@ -362,7 +375,6 @@ final class HomeViewModel { async let projectsTask = loadProjects(forceRefresh: forceRefresh) async let jobsTask = loadRecentJobs(forceRefresh: forceRefresh) async let assignedTicketsTask = loadAssignedTickets(forceRefresh: forceRefresh) - async let inboxUnreadTask = loadInboxUnreadSnapshot(forceRefresh: forceRefresh) async let systemStatusTask = loadSystemStatusSnapshot(forceRefresh: forceRefresh) // Resolve system status first so the Home title-bar status badge can @@ -413,13 +425,40 @@ final class HomeViewModel { } isLoadingAssignedTickets = false - let inboxUnreadSnapshot = await inboxUnreadTask - unreadInboxThreadCount = inboxUnreadSnapshot?.unreadCount - unreadInboxThreads = inboxUnreadSnapshot?.threads ?? [] - hasUnreadInboxThreads = (unreadInboxThreadCount ?? 0) > 0 lastRefreshed = Date() persistNeedsAttentionSnapshot() persistSystemStatusWidgetSnapshot() + + if awaitInboxUnread { + inboxRefreshTask?.cancel() + inboxRefreshTask = nil + applyInboxUnreadSnapshot(await loadInboxUnreadSnapshot(forceRefresh: forceRefresh)) + } else { + refreshInboxUnreadInBackground(forceRefresh: forceRefresh) + } + } + + /// Refreshes the inbox unread badge without blocking `loadDashboard`. + /// + /// Any in-flight refresh is cancelled so overlapping pulls don't stack + /// ~25s fetches. On cancellation the snapshot loader returns `nil`; the + /// early `Task.isCancelled` check then leaves the existing badge untouched + /// rather than wiping it, so a superseding refresh owns the final value. + private func refreshInboxUnreadInBackground(forceRefresh: Bool) { + inboxRefreshTask?.cancel() + inboxRefreshTask = Task { [weak self] in + guard let self else { return } + let snapshot = await self.loadInboxUnreadSnapshot(forceRefresh: forceRefresh) + guard !Task.isCancelled else { return } + self.applyInboxUnreadSnapshot(snapshot) + } + } + + private func applyInboxUnreadSnapshot(_ snapshot: HomeInboxUnreadSnapshot?) { + unreadInboxThreadCount = snapshot?.unreadCount + unreadInboxThreads = snapshot?.threads ?? [] + hasUnreadInboxThreads = (unreadInboxThreadCount ?? 0) > 0 + persistNeedsAttentionSnapshot() } /// Returns true if sufficient time has elapsed since the last dashboard refresh. -- cgit v1.2.3