9662c2abf6
Equal-score stories reshuffled on every pull-to-refresh because the sort was unstable. Add StorySummary.feedOrder (signalScore desc, then id desc, mirroring the backend's signal_score DESC, id DESC) and use it for the feed, the WebSocket re-sort, and the Saved/Search tabs. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
309 lines
11 KiB
Swift
309 lines
11 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
|
|
|
|
// Reusable wordmark: J in KisaniOrange, the rest white, weight 800, kerning -2.
|
|
struct JarvisWordmark: View {
|
|
var size: CGFloat = 30
|
|
var body: some View {
|
|
(Text("J").foregroundColor(Palette.orange) + Text("arvis").foregroundColor(.white))
|
|
.font(.system(size: size, weight: .heavy))
|
|
.kerning(-2)
|
|
}
|
|
}
|
|
|
|
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]
|
|
@State private var showFeeds = false
|
|
@State private var showSettings = 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)) }
|
|
|
|
/// Live stories when online; cached fallback when the feed is empty & offline.
|
|
private var displayStories: [StorySummary] {
|
|
if !store.stories.isEmpty {
|
|
return store.stories.sorted(by: StorySummary.feedOrder)
|
|
}
|
|
if !ws.connectionState.isLive {
|
|
return cachedStories
|
|
.map(StorySummary.init(cached:))
|
|
.sorted(by: StorySummary.feedOrder)
|
|
}
|
|
return []
|
|
}
|
|
|
|
var body: some View {
|
|
NavigationStack {
|
|
ZStack {
|
|
Color.black.ignoresSafeArea()
|
|
|
|
VStack(spacing: 0) {
|
|
header
|
|
syncBar
|
|
topicPills
|
|
columnHeaders
|
|
Divider().overlay(Palette.hairline)
|
|
feedList
|
|
}
|
|
}
|
|
.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()
|
|
}
|
|
}
|
|
.preferredColorScheme(.dark)
|
|
.onChange(of: store.stories) { _, newValue in
|
|
cacheStories(newValue)
|
|
}
|
|
}
|
|
|
|
// MARK: - Header
|
|
|
|
private var header: some View {
|
|
HStack(alignment: .center) {
|
|
JarvisWordmark(size: 30)
|
|
Spacer()
|
|
ConnectionBanner(state: ws.connectionState)
|
|
Button {
|
|
showFeeds = true
|
|
} label: {
|
|
Image(systemName: "dot.radiowaves.up.forward")
|
|
.font(.system(size: 17, weight: .semibold))
|
|
.foregroundStyle(Color(hex: "888888"))
|
|
.frame(width: 44, height: 44)
|
|
}
|
|
Button {
|
|
showSettings = true
|
|
} label: {
|
|
Image(systemName: "gearshape")
|
|
.font(.system(size: 17, weight: .semibold))
|
|
.foregroundStyle(Color(hex: "888888"))
|
|
.frame(width: 44, height: 44)
|
|
}
|
|
}
|
|
.padding(.horizontal, 16)
|
|
.padding(.top, 8)
|
|
}
|
|
|
|
// MARK: - Sync bar
|
|
|
|
private var syncBar: some View {
|
|
Text(syncText)
|
|
.font(.system(size: 11, weight: .regular, design: .monospaced))
|
|
.foregroundStyle(Color(hex: "5A5A5A"))
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.padding(.horizontal, 16)
|
|
.padding(.bottom, 12)
|
|
}
|
|
|
|
private var syncText: String {
|
|
let ago = syncedMinutesAgo(store.lastSyncedAt)
|
|
let phrase = (ago == "just now" || ago == "never") ? ago : "\(ago) ago"
|
|
if ws.connectionState.isLive {
|
|
return "Synced \(phrase) · \(cachedStoryIds.count) cached"
|
|
} else {
|
|
return "Last synced \(phrase)"
|
|
}
|
|
}
|
|
|
|
// MARK: - Topic pills
|
|
|
|
private var topicPills: some View {
|
|
ScrollView(.horizontal, showsIndicators: false) {
|
|
HStack(spacing: 8) {
|
|
ForEach(Topic.filters, id: \.label) { filter in
|
|
let selected = store.selectedTopic == filter.slug
|
|
Button {
|
|
Task { await store.setTopic(filter.slug) }
|
|
} label: {
|
|
Text(filter.label)
|
|
.font(.system(size: 13, weight: .bold))
|
|
.foregroundStyle(selected ? .black : Color(hex: "AAAAAA"))
|
|
.padding(.horizontal, 14)
|
|
.frame(height: 32)
|
|
.background(selected ? Palette.orange : Palette.surface)
|
|
.clipShape(Capsule())
|
|
}
|
|
}
|
|
}
|
|
.padding(.horizontal, 16)
|
|
}
|
|
.padding(.bottom, 14)
|
|
}
|
|
|
|
// 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(Color(hex: "555555"))
|
|
.padding(.horizontal, 16)
|
|
.padding(.bottom, 8)
|
|
}
|
|
|
|
// MARK: - Feed list
|
|
|
|
private var feedList: some View {
|
|
ScrollView {
|
|
LazyVStack(spacing: 0) {
|
|
if displayStories.isEmpty {
|
|
emptyState
|
|
} else {
|
|
ForEach(displayStories) { story in
|
|
NavigationLink(value: story) {
|
|
StoryRowView(story: story,
|
|
isCached: cachedStoryIds.contains(story.id),
|
|
isRead: readStoryIds.contains(story.id))
|
|
}
|
|
.buttonStyle(.plain)
|
|
.onAppear {
|
|
if story.id == displayStories.last?.id {
|
|
Task { await store.loadMore() }
|
|
}
|
|
}
|
|
}
|
|
|
|
if store.isLoadingMore {
|
|
ProgressView()
|
|
.tint(Palette.orange)
|
|
.padding(.vertical, 20)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.refreshable {
|
|
await store.loadStories(refresh: true)
|
|
}
|
|
}
|
|
|
|
private var emptyState: some View {
|
|
VStack(spacing: 12) {
|
|
if store.isLoading {
|
|
// Actively polling the server.
|
|
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(.white)
|
|
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(.white)
|
|
Text("No cached stories to show")
|
|
.font(.system(size: 12)).foregroundStyle(Color(hex: "888888"))
|
|
refreshButton("Retry")
|
|
} else {
|
|
// Connected, loaded, genuinely nothing yet.
|
|
emptyIcon("antenna.radiowaves.left.and.right")
|
|
Text("No signals yet").font(.system(size: 15, weight: .heavy)).foregroundStyle(.white)
|
|
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 = Color(hex: "333333")) -> 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(Color(hex: "555555"))
|
|
}
|
|
}
|
|
|
|
private func refreshButton(_ title: String) -> some View {
|
|
Button {
|
|
Task { await store.loadStories(refresh: true) }
|
|
} 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: - Caching
|
|
|
|
private func cacheStories(_ stories: [StorySummary]) {
|
|
for summary in stories {
|
|
let id = summary.id
|
|
let existing = try? modelContext.fetch(
|
|
FetchDescriptor<CachedStory>(predicate: #Predicate { $0.id == id })
|
|
)
|
|
if let found = existing?.first {
|
|
found.signalScore = summary.signalScore
|
|
found.sourceCount = summary.sourceCount
|
|
found.updatedAt = summary.updatedAt
|
|
} else {
|
|
modelContext.insert(CachedStory(from: summary))
|
|
}
|
|
}
|
|
try? modelContext.save()
|
|
}
|
|
}
|
|
|
|
// 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,
|
|
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.updatedAt
|
|
)
|
|
}
|
|
}
|