d62c3511f6
CI caught this: the sync-lag fix referenced a nonexistent SwiftUI environment value. The container is reached through the context. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
784 lines
32 KiB
Swift
784 lines
32 KiB
Swift
// SignalFeedView.swift
|
|
// Jarvis — home screen. Stories ranked by signal score, live connection state,
|
|
// topic filters, pull-to-refresh, infinite scroll.
|
|
|
|
import SwiftUI
|
|
import SwiftData
|
|
|
|
struct SignalFeedView: View {
|
|
@EnvironmentObject var store: StoryStore
|
|
@EnvironmentObject var ws: WebSocketManager
|
|
@EnvironmentObject var settings: ServerSettings
|
|
@Environment(\.modelContext) private var modelContext
|
|
|
|
@Query private var cachedStories: [CachedStory]
|
|
@Query private var cachedArticles: [CachedArticle]
|
|
@Query private var readStories: [ReadStory]
|
|
@Query private var savedStories: [SavedStory]
|
|
@State private var showFeeds = false
|
|
@State private var showSettings = false
|
|
@State private var selectedPill: StoryPill = .all
|
|
@State private var shareStory: StorySummary?
|
|
/// Snapshot of already-seen story ids, captured per load so the order stays
|
|
/// stable while scrolling (and refreshes to sink newly-seen ones).
|
|
@State private var seenSnapshot: Set<String> = []
|
|
/// Reference-type set so marking a story seen on scroll doesn't re-render.
|
|
@State private var seenTracker = SeenTracker()
|
|
@State private var showRead = false
|
|
@State private var markAllToast: String?
|
|
@State private var markAllPending = false
|
|
|
|
/// Stories that have full article content cached → eligible for the green dot.
|
|
private var cachedStoryIds: Set<String> { Set(cachedArticles.map(\.storyId)) }
|
|
private var readStoryIds: Set<String> { Set(readStories.map(\.id)) }
|
|
private var savedStoryIds: Set<String> { Set(savedStories.map(\.id)) }
|
|
|
|
/// Live stories when connected; cached fallback while loading or offline so
|
|
/// switching to Tech / AI / F1 shows cached cards instantly.
|
|
/// Before the first sync of this session completes, only unread stories are
|
|
/// surfaced — read content is irrelevant until we know there's nothing newer.
|
|
private var filteredStories: [StorySummary] {
|
|
let base: [StorySummary]
|
|
if !store.stories.isEmpty {
|
|
base = store.stories.sorted(by: StorySummary.feedOrder)
|
|
} else {
|
|
base = cachedStories.map(StorySummary.init(cached:)).sorted(by: StorySummary.feedOrder)
|
|
}
|
|
let matched = base.filter { $0.matches(selectedPill) }
|
|
if store.lastSyncedAt == nil {
|
|
return matched.filter { !readStoryIds.contains($0.id) }
|
|
}
|
|
return matched
|
|
}
|
|
|
|
/// The main feed: unread stories, with already-seen ones sunk below fresh ones.
|
|
private var mainStories: [StorySummary] {
|
|
let notRead = filteredStories.filter { !readStoryIds.contains($0.id) }
|
|
let fresh = notRead.filter { !seenSnapshot.contains($0.id) }
|
|
let seen = notRead.filter { seenSnapshot.contains($0.id) }
|
|
return fresh + seen
|
|
}
|
|
|
|
/// Read stories, tucked into the collapsible "Read" shelf.
|
|
private var readItems: [StorySummary] {
|
|
filteredStories.filter { readStoryIds.contains($0.id) }
|
|
}
|
|
|
|
/// Every pill shows the card layout — sections are scoped to "All".
|
|
private var isDigest: Bool { true }
|
|
|
|
/// Front-page digest: Top Stories + up to 4 per category section, deduped.
|
|
/// Sections that score poorly in the global top-100 are supplemented from
|
|
/// per-section targeted fetches held in store.sectionSupplement.
|
|
private func makeDigest(sections: [NewsSection]) -> (top: [StorySummary], sections: [(NewsSection, [StorySummary])]) {
|
|
let unread = filteredStories.filter { !readStoryIds.contains($0.id) }
|
|
let top = Array(unread.prefix(5))
|
|
var pool = Array(unread.dropFirst(5))
|
|
var usedIds = Set(top.map(\.id))
|
|
var out: [(NewsSection, [StorySummary])] = []
|
|
for section in sections {
|
|
var picked: [StorySummary] = [], rest: [StorySummary] = []
|
|
for s in pool {
|
|
if picked.count < 4 && s.inSection(section) { picked.append(s) }
|
|
else { rest.append(s) }
|
|
}
|
|
pool = rest
|
|
// Supplement from section-specific fetch when main pool is sparse
|
|
if picked.count < 2, let extra = store.sectionSupplement[section.id] {
|
|
for s in extra where !usedIds.contains(s.id) && s.inSection(section) {
|
|
picked.append(s)
|
|
usedIds.insert(s.id)
|
|
if picked.count == 4 { break }
|
|
}
|
|
}
|
|
usedIds.formUnion(picked.map(\.id))
|
|
if !picked.isEmpty { out.append((section, picked)) }
|
|
}
|
|
return (top, out)
|
|
}
|
|
|
|
private func captureSeenSnapshot() {
|
|
let ids = (try? modelContext.fetch(FetchDescriptor<SeenStory>()))?.map(\.id) ?? []
|
|
seenSnapshot = Set(ids)
|
|
seenTracker.ids = seenSnapshot
|
|
}
|
|
|
|
/// Hot path — runs as each row scrolls in. O(1), no disk write, no re-render:
|
|
/// the container autosaves, and SeenStory isn't @Query'd by this view.
|
|
private func markSeen(_ s: StorySummary) {
|
|
guard seenTracker.ids.insert(s.id).inserted else { return }
|
|
modelContext.insert(SeenStory(id: s.id))
|
|
}
|
|
|
|
private func markUnread(_ s: StorySummary) {
|
|
let id = s.id
|
|
if let row = (try? modelContext.fetch(
|
|
FetchDescriptor<ReadStory>(predicate: #Predicate { $0.id == id })))?.first {
|
|
modelContext.delete(row)
|
|
try? modelContext.save()
|
|
Task { try? await APIClient.shared.markStoryUnread(id: id) }
|
|
}
|
|
}
|
|
|
|
var body: some View {
|
|
NavigationStack {
|
|
ZStack(alignment: .bottom) {
|
|
Palette.background.ignoresSafeArea()
|
|
|
|
VStack(spacing: 0) {
|
|
header
|
|
syncBar
|
|
topicPills
|
|
Divider().overlay(Palette.hairline)
|
|
feedList
|
|
}
|
|
|
|
if let toast = markAllToast {
|
|
Text(toast)
|
|
.font(.system(size: 13, weight: .medium, design: .monospaced))
|
|
.foregroundStyle(Color(hex: "E0E0E0"))
|
|
.padding(.horizontal, 18)
|
|
.padding(.vertical, 11)
|
|
.background(Color(hex: "1E1E1E"))
|
|
.clipShape(Capsule())
|
|
.overlay(Capsule().stroke(Color(hex: "333333"), lineWidth: 0.5))
|
|
.shadow(color: .black.opacity(0.4), radius: 12, y: 4)
|
|
.padding(.bottom, 24)
|
|
.transition(.move(edge: .bottom).combined(with: .opacity))
|
|
.onAppear {
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + 3.5) {
|
|
withAnimation(.easeOut(duration: 0.25)) { markAllToast = nil }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.navigationBarHidden(true)
|
|
.navigationDestination(for: StorySummary.self) { story in
|
|
StoryDetailView(story: story)
|
|
}
|
|
.navigationDestination(for: ArticleRoute.self) { route in
|
|
ArticleReaderView(route: route)
|
|
}
|
|
.sheet(isPresented: $showFeeds) {
|
|
FeedManagerView()
|
|
}
|
|
.sheet(isPresented: $showSettings) {
|
|
SettingsView()
|
|
}
|
|
.sheet(item: $shareStory) { story in
|
|
ShareSheet(items: shareItems(story))
|
|
}
|
|
}
|
|
.onChange(of: store.stories) { _, newValue in
|
|
cacheStories(newValue)
|
|
}
|
|
.task { CacheMaintenance.prune(modelContext) } // bound the caches on launch
|
|
.task(id: selectedPill) {
|
|
await store.setPill(selectedPill) // paginates to 100 stories internally
|
|
}
|
|
}
|
|
|
|
// MARK: - Header
|
|
|
|
private var header: some View {
|
|
HStack(alignment: .center, spacing: 0) {
|
|
JarvisWordmark(size: 26)
|
|
Spacer()
|
|
// Connection + controls as one coherent surface
|
|
HStack(spacing: 2) {
|
|
ConnectionBanner(state: ws.connectionState)
|
|
Button {
|
|
showFeeds = true
|
|
} label: {
|
|
Image(systemName: "dot.radiowaves.up.forward")
|
|
.font(.system(size: 15, weight: .medium))
|
|
.foregroundStyle(Palette.secondaryText)
|
|
.frame(width: 40, height: 40)
|
|
}
|
|
Menu {
|
|
Button {
|
|
Task { await markAllRead() }
|
|
} label: {
|
|
Label(
|
|
markAllPending ? "Marking…" : "Mark all as read",
|
|
systemImage: markAllPending ? "hourglass" : "checkmark.circle"
|
|
)
|
|
}
|
|
.disabled(markAllPending || mainStories.isEmpty)
|
|
Divider()
|
|
Button {
|
|
showSettings = true
|
|
} label: {
|
|
Label("Settings", systemImage: "gearshape")
|
|
}
|
|
} label: {
|
|
Image(systemName: "ellipsis")
|
|
.font(.system(size: 15, weight: .medium))
|
|
.foregroundStyle(Palette.secondaryText)
|
|
.frame(width: 40, height: 40)
|
|
}
|
|
}
|
|
}
|
|
.padding(.horizontal, 16)
|
|
.padding(.top, 8)
|
|
}
|
|
|
|
// MARK: - Sync bar
|
|
|
|
/// True while the first sync of this session hasn't completed yet, OR while
|
|
/// a fetch is actively in flight. Used to gate the "caught up" state so we
|
|
/// never declare victory before we've actually checked the server.
|
|
private var isSyncing: Bool { store.isLoading || store.lastSyncedAt == nil }
|
|
|
|
private var syncBar: some View {
|
|
HStack(spacing: 5) {
|
|
if isSyncing {
|
|
ProgressView()
|
|
.progressViewStyle(.circular)
|
|
.controlSize(.mini)
|
|
.tint(Palette.orange)
|
|
}
|
|
Text(isSyncing ? "Syncing signals…" : syncText)
|
|
.font(.system(size: 11, weight: .regular, design: .monospaced))
|
|
.foregroundStyle(Color(hex: "5A5A5A"))
|
|
.animation(.easeInOut(duration: 0.15), value: store.isLoading)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.padding(.horizontal, 16)
|
|
.padding(.bottom, 12)
|
|
}
|
|
|
|
private var syncText: String {
|
|
guard let last = store.lastSyncedAt else { return "Loading from cache…" }
|
|
let ago = last.timeAgoShort()
|
|
let phrase = ago == "just now" ? ago : "\(ago) ago"
|
|
if ws.connectionState.isLive {
|
|
return "Synced \(phrase) · \(cachedStoryIds.count) cached"
|
|
} else {
|
|
return "Last synced \(phrase)"
|
|
}
|
|
}
|
|
|
|
// MARK: - Pills
|
|
|
|
private var topicPills: some View {
|
|
ScrollView(.horizontal, showsIndicators: false) {
|
|
HStack(spacing: 8) {
|
|
ForEach(StoryPill.allCases) { p in
|
|
pill(p.label, selected: selectedPill == p) {
|
|
selectedPill = p
|
|
}
|
|
}
|
|
}
|
|
.padding(.horizontal, 16)
|
|
}
|
|
.padding(.bottom, 14)
|
|
}
|
|
|
|
private func pill(_ label: String, selected: Bool, action: @escaping () -> Void) -> some View {
|
|
Button(action: action) {
|
|
Text(label)
|
|
.font(.system(size: 12, weight: selected ? .semibold : .medium))
|
|
.foregroundStyle(selected ? .black : Palette.secondaryText)
|
|
.padding(.horizontal, 13)
|
|
.frame(height: 28)
|
|
.background(selected ? Palette.orange : Palette.surface)
|
|
.clipShape(Capsule())
|
|
}
|
|
}
|
|
|
|
// MARK: - Column headers
|
|
|
|
private var columnHeaders: some View {
|
|
HStack {
|
|
Text("STORY")
|
|
.kerning(0.8)
|
|
Spacer()
|
|
Text("SIGNAL ↓")
|
|
.kerning(0.8)
|
|
}
|
|
.font(.system(size: 10, weight: .bold, design: .monospaced))
|
|
.foregroundStyle(Palette.tertiaryText)
|
|
.padding(.horizontal, 16)
|
|
.padding(.bottom, 8)
|
|
}
|
|
|
|
// MARK: - Feed list
|
|
|
|
private var feedList: some View {
|
|
List {
|
|
digestContent
|
|
}
|
|
.listStyle(.plain)
|
|
.scrollContentBackground(.hidden)
|
|
.background(Palette.background)
|
|
.animation(.snappy, value: showRead)
|
|
.animation(.snappy, value: readStories.count)
|
|
.onAppear {
|
|
captureSeenSnapshot()
|
|
// If the cache already shows all-read on first render, open the
|
|
// shelf immediately so the user sees their previous stories.
|
|
if !readItems.isEmpty && mainStories.isEmpty { showRead = true }
|
|
}
|
|
// Expand shelf when loading finishes and there are still no unread stories.
|
|
.onChange(of: store.isLoading) { _, loading in
|
|
if !loading, !readItems.isEmpty, mainStories.isEmpty {
|
|
withAnimation(.snappy) { showRead = true }
|
|
}
|
|
}
|
|
// Expand shelf if SwiftData @Query hydrates after the first render and
|
|
// all cached stories turn out to already be read.
|
|
.onChange(of: readItems.count) { _, count in
|
|
if count > 0, mainStories.isEmpty, !showRead {
|
|
showRead = true
|
|
}
|
|
}
|
|
.refreshable {
|
|
seenSnapshot = []
|
|
seenTracker.ids = []
|
|
await store.loadFeedFull()
|
|
// Merge any stories cached by background refresh that aren't in
|
|
// the live feed yet — mergeStories deduplicates, so always safe.
|
|
let liveIds = Set(store.stories.map(\.id))
|
|
let extra = cachedStories
|
|
.filter { !liveIds.contains($0.id) }
|
|
.map(StorySummary.init(cached:))
|
|
if !extra.isEmpty {
|
|
await store.mergeStories(extra)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Card layout for every pill.
|
|
/// "All" → multi-section digest. Tech (sub-sections) → sub-section digest.
|
|
/// Everything else → hero card + flat scroll of all stories for that pill.
|
|
@ViewBuilder private var digestContent: some View {
|
|
if selectedPill == .all {
|
|
let d = makeDigest(sections: NewsSection.sections)
|
|
sectionHeader("TOP STORIES", pill: nil)
|
|
pillContent(top: d.top)
|
|
ForEach(d.sections, id: \.0.id) { section, stories in
|
|
sectionHeader(section.label.uppercased(), pill: section.pill)
|
|
ForEach(stories) { mainRow($0) }
|
|
}
|
|
} else if let subSections = selectedPill.subSections {
|
|
let d = makeDigest(sections: subSections)
|
|
sectionHeader(selectedPill.label.uppercased(), pill: nil)
|
|
pillContent(top: d.top)
|
|
ForEach(d.sections, id: \.0.id) { section, stories in
|
|
sectionHeader(section.label.uppercased(), pill: section.pill)
|
|
ForEach(stories) { mainRow($0) }
|
|
}
|
|
} else {
|
|
// Flat list: hero + all stories for this pill
|
|
sectionHeader(selectedPill.label.uppercased(), pill: nil)
|
|
pillContent(top: mainStories, flat: true)
|
|
}
|
|
readShelf
|
|
}
|
|
|
|
/// Shared hero + body rows. `flat` = render all items; otherwise only top 5.
|
|
@ViewBuilder private func pillContent(top stories: [StorySummary], flat: Bool = false) -> some View {
|
|
if let lead = stories.first {
|
|
mainRow(lead, hero: true)
|
|
let rest = flat ? Array(stories.dropFirst()) : Array(stories.dropFirst().prefix(4))
|
|
ForEach(rest) { mainRow($0) }
|
|
} else if !filteredStories.isEmpty {
|
|
if isSyncing { checkingRow.plainBlackRow() }
|
|
else { caughtUpRow.plainBlackRow() }
|
|
} else {
|
|
emptyState.plainBlackRow()
|
|
}
|
|
}
|
|
|
|
private func sectionHeader(_ label: String, pill: StoryPill?) -> some View {
|
|
HStack(alignment: .firstTextBaseline) {
|
|
Text(label)
|
|
.font(.system(size: 13, weight: .heavy, design: .monospaced))
|
|
.kerning(0.6)
|
|
.foregroundStyle(Palette.primaryText)
|
|
Rectangle().fill(Palette.orange).frame(width: 18, height: 2)
|
|
Spacer()
|
|
if let pill {
|
|
Button {
|
|
selectedPill = pill
|
|
} label: {
|
|
HStack(spacing: 2) {
|
|
Text("See all"); Image(systemName: "chevron.right").font(.system(size: 10, weight: .bold))
|
|
}
|
|
.font(.system(size: 12, weight: .bold))
|
|
.foregroundStyle(Palette.orange)
|
|
}
|
|
}
|
|
}
|
|
.padding(.horizontal, 16).padding(.top, 22).padding(.bottom, 10)
|
|
.plainBlackRow()
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func mainRow(_ story: StorySummary, hero: Bool = false) -> some View {
|
|
NavigationLink(value: story) {
|
|
if hero {
|
|
heroCard(story)
|
|
} else {
|
|
StoryRowView(story: story, isCached: cachedStoryIds.contains(story.id))
|
|
}
|
|
}
|
|
.listRowInsets(hero ? EdgeInsets(top: 2, leading: 16, bottom: 12, trailing: 16) : EdgeInsets())
|
|
.listRowBackground(Palette.background)
|
|
.listRowSeparator(.hidden)
|
|
.onAppear {
|
|
markSeen(story)
|
|
if story.id == mainStories.last?.id { Task { await store.loadMore() } }
|
|
}
|
|
// Swipe left: short swipe reveals Save (tap); a full/long swipe marks read.
|
|
.swipeActions(edge: .trailing, allowsFullSwipe: true) {
|
|
Button { markRead(story) } label: {
|
|
Label("Mark read", systemImage: "checkmark.circle")
|
|
}
|
|
.tint(Color(hex: "3A5A7A"))
|
|
Button { toggleSave(story) } label: {
|
|
Label(isSaved(story) ? "Saved" : "Save",
|
|
systemImage: isSaved(story) ? "bookmark.fill" : "bookmark")
|
|
}
|
|
.tint(Palette.healthActive)
|
|
}
|
|
// Swipe right → Share.
|
|
.swipeActions(edge: .leading, allowsFullSwipe: true) {
|
|
Button { markRead(story); shareStory = story } label: {
|
|
Label("Share", systemImage: "square.and.arrow.up")
|
|
}
|
|
.tint(Palette.orange)
|
|
}
|
|
}
|
|
|
|
/// Apple-News-style lead card for the #1 Top Story — flat surface, big type.
|
|
private func heroCard(_ story: StorySummary) -> some View {
|
|
HStack(alignment: .top, spacing: 0) {
|
|
SignalStripe(score: story.signalScore, width: 4)
|
|
VStack(alignment: .leading, spacing: 11) {
|
|
HStack(alignment: .center) {
|
|
Text(Topic.label(story.topic).uppercased())
|
|
.font(.system(size: 10, weight: .bold, design: .monospaced)).kerning(0.8)
|
|
.foregroundStyle(Palette.secondaryText)
|
|
Spacer()
|
|
Text("\(story.signalScore)")
|
|
.font(.system(size: 15, weight: .semibold, design: .monospaced))
|
|
.foregroundStyle(Signal.scoreColor(story.signalScore))
|
|
}
|
|
Text(story.headline)
|
|
.font(.system(size: 25, weight: .bold, design: .default))
|
|
.foregroundStyle(Palette.primaryText)
|
|
.lineLimit(4)
|
|
.fixedSize(horizontal: false, vertical: true)
|
|
if !story.summary.isEmpty {
|
|
Text(story.summary)
|
|
.font(.system(size: 16, weight: .regular, design: .default))
|
|
.foregroundStyle(Palette.bodyText)
|
|
.lineLimit(3).lineSpacing(2)
|
|
.fixedSize(horizontal: false, vertical: true)
|
|
}
|
|
if !story.sources.isEmpty {
|
|
SourceChips(names: story.sources.map(\.name), total: story.sourceCount)
|
|
}
|
|
Text("\(story.sourceCount) sources · \(story.updatedAt.timeAgoShort()) ago")
|
|
.font(.system(size: 11, weight: .regular, design: .monospaced))
|
|
.foregroundStyle(Palette.tertiaryText)
|
|
}
|
|
.padding(16)
|
|
Spacer(minLength: 0)
|
|
}
|
|
.background(Palette.surface)
|
|
.clipShape(RoundedRectangle(cornerRadius: 16))
|
|
.overlay(RoundedRectangle(cornerRadius: 16).stroke(Palette.surface2, lineWidth: 0.5))
|
|
}
|
|
|
|
/// Shown when all cached stories are read AND the first sync hasn't finished yet.
|
|
/// Keeps the UI honest — we haven't confirmed "no new content" until the server responds.
|
|
private var checkingRow: some View {
|
|
VStack(spacing: 8) {
|
|
ProgressView()
|
|
.progressViewStyle(.circular)
|
|
.controlSize(.mini)
|
|
.tint(Palette.orange)
|
|
Text("Checking for new signals…")
|
|
.font(.system(size: 12, weight: .bold, design: .monospaced))
|
|
.foregroundStyle(Palette.tertiaryText)
|
|
}
|
|
.frame(maxWidth: .infinity)
|
|
.padding(.vertical, 50)
|
|
}
|
|
|
|
private var caughtUpRow: some View {
|
|
VStack(spacing: 10) {
|
|
Image(systemName: "checkmark.circle")
|
|
.font(.system(size: 32)).foregroundStyle(Color(hex: "3E7E3E"))
|
|
Text("You're all caught up").font(.system(size: 16, weight: .semibold, design: .default)).foregroundStyle(Palette.primaryText)
|
|
Text("Pull to refresh for more")
|
|
.font(.system(size: 12)).foregroundStyle(Color(hex: "888888"))
|
|
}
|
|
.frame(maxWidth: .infinity).padding(.vertical, 70)
|
|
}
|
|
|
|
// Collapsible "Read" shelf at the bottom — read stories as slim rows.
|
|
@ViewBuilder
|
|
private var readShelf: some View {
|
|
if !readItems.isEmpty {
|
|
Button {
|
|
withAnimation(.snappy) { showRead.toggle() }
|
|
} label: {
|
|
HStack(spacing: 8) {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.font(.system(size: 13)).foregroundStyle(Color(hex: "3E7E3E"))
|
|
Text("READ").font(.system(size: 11, weight: .bold, design: .monospaced)).kerning(0.8)
|
|
Text("\(readItems.count)")
|
|
.font(.system(size: 11, weight: .bold, design: .monospaced))
|
|
.foregroundStyle(Color(hex: "888888"))
|
|
Spacer()
|
|
Image(systemName: showRead ? "chevron.up" : "chevron.down")
|
|
.font(.system(size: 11, weight: .bold))
|
|
}
|
|
.foregroundStyle(Palette.tertiaryText)
|
|
.padding(.horizontal, 16).padding(.vertical, 16)
|
|
.contentShape(Rectangle())
|
|
}
|
|
.buttonStyle(.plain)
|
|
.plainBlackRow()
|
|
|
|
if showRead {
|
|
ForEach(readItems) { story in
|
|
NavigationLink(value: story) {
|
|
StoryRowView(story: story, isCached: cachedStoryIds.contains(story.id),
|
|
isRead: true, compact: true)
|
|
}
|
|
.plainBlackRow()
|
|
.swipeActions(edge: .trailing, allowsFullSwipe: true) {
|
|
Button { markUnread(story) } label: {
|
|
Label("Unread", systemImage: "circle")
|
|
}
|
|
.tint(Color(hex: "3A5A7A"))
|
|
Button { toggleSave(story) } label: {
|
|
Label(isSaved(story) ? "Saved" : "Save",
|
|
systemImage: isSaved(story) ? "bookmark.fill" : "bookmark")
|
|
}
|
|
.tint(Palette.healthActive)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private var emptyState: some View {
|
|
VStack(spacing: 12) {
|
|
if isSyncing {
|
|
// First sync hasn't completed yet, or a fetch is actively in flight.
|
|
ProgressView().tint(Palette.orange)
|
|
Text("Polling signals…")
|
|
.font(.system(size: 14, weight: .heavy))
|
|
.foregroundStyle(Color(hex: "AAAAAA"))
|
|
hostLine
|
|
} else if let error = store.error {
|
|
// Reached the empty state because the fetch failed.
|
|
emptyIcon("exclamationmark.triangle", color: Color(hex: "C25555"))
|
|
Text("Couldn't reach the server")
|
|
.font(.system(size: 15, weight: .heavy)).foregroundStyle(Palette.primaryText)
|
|
Text(error.errorDescription ?? "Unknown error")
|
|
.font(.system(size: 12)).foregroundStyle(Color(hex: "888888"))
|
|
.multilineTextAlignment(.center)
|
|
hostLine
|
|
refreshButton("Retry")
|
|
} else if !ws.connectionState.isLive {
|
|
emptyIcon("wifi.slash")
|
|
Text("Offline").font(.system(size: 15, weight: .heavy)).foregroundStyle(Palette.primaryText)
|
|
Text("No cached stories to show")
|
|
.font(.system(size: 12)).foregroundStyle(Color(hex: "888888"))
|
|
refreshButton("Retry")
|
|
} else if selectedPill != .all {
|
|
emptyIcon("line.3.horizontal.decrease.circle")
|
|
Text("No \(selectedPill.label) stories yet")
|
|
.font(.system(size: 15, weight: .heavy)).foregroundStyle(Palette.primaryText)
|
|
if store.isLoadingMore || store.hasMore {
|
|
Text("Pulling more to find them…")
|
|
.font(.system(size: 12)).foregroundStyle(Color(hex: "888888"))
|
|
ProgressView().tint(Palette.orange)
|
|
} else {
|
|
Text("Nothing in the feed matched")
|
|
.font(.system(size: 12)).foregroundStyle(Color(hex: "888888"))
|
|
refreshButton("Refresh")
|
|
}
|
|
} else {
|
|
// Connected, loaded, genuinely nothing yet.
|
|
emptyIcon("antenna.radiowaves.left.and.right")
|
|
Text("No signals yet").font(.system(size: 15, weight: .heavy)).foregroundStyle(Palette.primaryText)
|
|
Text("Pull to refresh")
|
|
.font(.system(size: 12)).foregroundStyle(Color(hex: "888888"))
|
|
refreshButton("Refresh")
|
|
}
|
|
}
|
|
.frame(maxWidth: .infinity)
|
|
.padding(.horizontal, 32)
|
|
.padding(.top, 80)
|
|
}
|
|
|
|
private func emptyIcon(_ name: String, color: Color = Palette.mutedText) -> some View {
|
|
Image(systemName: name).font(.system(size: 30)).foregroundStyle(color)
|
|
}
|
|
|
|
@ViewBuilder private var hostLine: some View {
|
|
if let host = settings.host {
|
|
Text(host)
|
|
.font(.system(size: 11, design: .monospaced))
|
|
.foregroundStyle(Palette.tertiaryText)
|
|
}
|
|
}
|
|
|
|
private func refreshButton(_ title: String) -> some View {
|
|
Button {
|
|
Task { await store.loadFeedFull() }
|
|
} label: {
|
|
Text(title)
|
|
.font(.system(size: 14, weight: .bold)).foregroundStyle(.black)
|
|
.padding(.horizontal, 22).frame(height: 44)
|
|
.background(Palette.orange).clipShape(Capsule())
|
|
}
|
|
.padding(.top, 6)
|
|
}
|
|
|
|
// MARK: - Swipe actions
|
|
|
|
private func isSaved(_ s: StorySummary) -> Bool { savedStoryIds.contains(s.id) }
|
|
|
|
/// Swipe left → toggle Save (bookmarks the story to the Saved tab).
|
|
private func toggleSave(_ s: StorySummary) {
|
|
let id = s.id
|
|
if let row = (try? modelContext.fetch(
|
|
FetchDescriptor<SavedStory>(predicate: #Predicate { $0.id == id })))?.first {
|
|
modelContext.delete(row)
|
|
} else {
|
|
cacheStories([s]) // keep metadata so it renders in Saved
|
|
modelContext.insert(SavedStory(id: id))
|
|
}
|
|
try? modelContext.save()
|
|
}
|
|
|
|
private func markRead(_ s: StorySummary) {
|
|
let id = s.id
|
|
let existing = try? modelContext.fetch(
|
|
FetchDescriptor<ReadStory>(predicate: #Predicate { $0.id == id }))
|
|
if existing?.first == nil {
|
|
modelContext.insert(ReadStory(id: id))
|
|
try? modelContext.save()
|
|
Task { try? await APIClient.shared.markStoryRead(id: id) }
|
|
withAnimation(.snappy) { showRead = true }
|
|
}
|
|
}
|
|
|
|
private func markAllRead() async {
|
|
let ids = mainStories.map(\.id).filter { !readStoryIds.contains($0) }
|
|
guard !ids.isEmpty else {
|
|
withAnimation { markAllToast = "No unread \(selectedPill.label) stories right now." }
|
|
return
|
|
}
|
|
markAllPending = true
|
|
|
|
// Optimistic: insert ReadStory for every ID being marked.
|
|
for id in ids {
|
|
let exists = (try? modelContext.fetch(
|
|
FetchDescriptor<ReadStory>(predicate: #Predicate { $0.id == id })))?.first
|
|
if exists == nil { modelContext.insert(ReadStory(id: id)) }
|
|
}
|
|
try? modelContext.save()
|
|
withAnimation(.snappy) {
|
|
showRead = true
|
|
markAllToast = "Marked \(ids.count) \(ids.count == 1 ? "story" : "stories") as read."
|
|
}
|
|
|
|
do {
|
|
try await APIClient.shared.markAllRead(storyIds: ids, pill: selectedPill.label)
|
|
} catch {
|
|
// Rollback optimistic state.
|
|
for id in ids {
|
|
if let row = (try? modelContext.fetch(
|
|
FetchDescriptor<ReadStory>(predicate: #Predicate { $0.id == id })))?.first {
|
|
modelContext.delete(row)
|
|
}
|
|
}
|
|
try? modelContext.save()
|
|
withAnimation {
|
|
markAllToast = "Sync failed. Stories may reappear until retry."
|
|
}
|
|
}
|
|
markAllPending = false
|
|
}
|
|
|
|
private func shareItems(_ s: StorySummary) -> [Any] {
|
|
var items: [Any] = ["\(s.headline)\n\n\(s.summary)\n\nvia Jarvis"]
|
|
if let first = s.sources.first, let url = URL(string: first.url) {
|
|
items.append(url)
|
|
}
|
|
return items
|
|
}
|
|
|
|
// MARK: - Caching
|
|
|
|
private func cacheStories(_ stories: [StorySummary]) {
|
|
guard !stories.isEmpty else { return }
|
|
let container = modelContext.container
|
|
Task.detached {
|
|
let ctx = ModelContext(container)
|
|
let existing = (try? ctx.fetch(FetchDescriptor<CachedStory>())) ?? []
|
|
var byId = Dictionary(existing.map { ($0.id, $0) }, uniquingKeysWith: { a, _ in a })
|
|
for summary in stories {
|
|
if let found = byId[summary.id] {
|
|
found.signalScore = summary.signalScore
|
|
found.sourceCount = summary.sourceCount
|
|
found.tags = summary.tags ?? []
|
|
found.updatedAt = summary.updatedAt
|
|
} else {
|
|
let c = CachedStory(from: summary)
|
|
ctx.insert(c)
|
|
byId[summary.id] = c
|
|
}
|
|
}
|
|
try? ctx.save()
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Session-seen ids in a reference type — mutating it doesn't trigger SwiftUI
|
|
/// updates, so marking rows seen on scroll stays cheap.
|
|
private final class SeenTracker {
|
|
var ids = Set<String>()
|
|
}
|
|
|
|
// Map a cached story back into a StorySummary for offline rendering.
|
|
extension StorySummary {
|
|
init(cached: CachedStory) {
|
|
self.init(
|
|
id: cached.id,
|
|
headline: cached.headline,
|
|
summary: cached.summary,
|
|
topic: cached.topic,
|
|
tags: cached.tags,
|
|
signalScore: cached.signalScore,
|
|
scoreBreakdown: ScoreBreakdown(sourceAuthority: 0, freshness: 0, localRelevance: 0,
|
|
crossSourceConfirmation: 0, topicImportance: 0),
|
|
sourceCount: cached.sourceCount,
|
|
sources: [],
|
|
consensus: cached.consensus,
|
|
conflict: cached.conflict,
|
|
updatedAt: cached.updatedAt,
|
|
createdAt: cached.createdAt
|
|
)
|
|
}
|
|
}
|
|
|
|
private extension View {
|
|
/// Full-bleed black List row with no separator — keeps the flat feed look.
|
|
func plainBlackRow() -> some View {
|
|
self.listRowInsets(EdgeInsets())
|
|
.listRowBackground(Palette.background)
|
|
.listRowSeparator(.hidden)
|
|
}
|
|
}
|