Improve timeline auto-fetch for filtered empty results

Adds logic to TimelineViewModel to automatically fetch additional pages when all fetched statuses are filtered out, up to a limit. Updates constants for page sizes, and introduces tests and test utilities to verify the new behavior. Also adds a custom decoder to Quote to handle invalid quotedStatus values gracefully.

Author: Dimillian

CLAUDE.md

@@ -17,18 +17,17 @@ mcp__XcodeBuildMCP__build_sim_name_proj projectPath: "/Users/thomas/Documents/De
 
 ### Running Tests
 - **All tests**: Run through Xcode's Test navigator
-- **Specific package tests**:
+- **Specific package tests (XcodeBuildMCP on simulator)**:
   ```bash
-  xcodebuild -scheme AccountTests test
-  xcodebuild -scheme ModelsTests test
-  xcodebuild -scheme NetworkTests test
-  xcodebuild -scheme TimelineTests test
-  xcodebuild -scheme EnvTests test
-  ```
-- **Swift Package Manager** (for individual packages):
-  ```bash
-  cd Packages/[PackageName]
-  swift test
+  # Set defaults once per session
+  mcp__XcodeBuildMCP__session-set-defaults projectPath: "/Users/thomas/Documents/Dev/Open Source/IceCubesApp/IceCubesApp.xcodeproj" simulatorName: "iPhone Air"
+
+  # Then run any package test scheme
+  mcp__XcodeBuildMCP__test_sim scheme: "AccountTests"
+  mcp__XcodeBuildMCP__test_sim scheme: "ModelsTests"
+  mcp__XcodeBuildMCP__test_sim scheme: "NetworkTests"
+  mcp__XcodeBuildMCP__test_sim scheme: "TimelineTests"
+  mcp__XcodeBuildMCP__test_sim scheme: "EnvTests"
   ```
 
 ### Code Formatting

Packages/Models/Sources/Models/Quote.swift

@@ -8,4 +8,11 @@ public struct Quote: Codable, Sendable {
   public let state: State?
   public let quotedStatus: Status?
   public let quotedStatusId: String?
+
+  public init(from decoder: Decoder) throws {
+    let container = try decoder.container(keyedBy: CodingKeys.self)
+    state = try? container.decode(State.self, forKey: .state)
+    quotedStatusId = try? container.decode(String.self, forKey: .quotedStatusId)
+    quotedStatus = try? container.decode(Status.self, forKey: .quotedStatus)
+  }
 }

Packages/Models/Tests/ModelsTests/QuoteTests.swift

@@ -0,0 +1,23 @@
+import Foundation
+import Testing
+
+@testable import Models
+
+@Test
+func testQuoteDecodingIgnoresInvalidQuotedStatus() throws {
+  let decoder = JSONDecoder()
+  decoder.keyDecodingStrategy = .convertFromSnakeCase
+
+  let json = """
+    {
+      "state": "accepted",
+      "quoted_status_id": "123",
+      "quoted_status": "invalid"
+    }
+    """
+
+  let quote = try decoder.decode(Quote.self, from: Data(json.utf8))
+  #expect(quote.state == .accepted)
+  #expect(quote.quotedStatusId == "123")
+  #expect(quote.quotedStatus == nil)
+}

Packages/Timeline/Sources/Timeline/View/TimelineViewModel.swift

@@ -69,6 +69,9 @@ import SwiftUI
   private enum Constants {
     static let fullTimelineFetchLimit = 800
     static let fullTimelineFetchMaxPages = fullTimelineFetchLimit / 40
+    static let initialPageLimit = 50
+    static let nextPageLimit = 40
+    static let emptyFilterAutoPageLimit = 3
   }
 
   private var isFullTimelineFetchEnabled: Bool {
@@ -276,10 +279,20 @@ extension TimelineViewModel: GapLoadingFetcher {
         timeline: timeline)
 
       await updateDatasourceAndState(statuses: statuses, client: client, replaceExisting: true)
+      let lastCount = await autoFetchNextPagesIfFilteredEmpty(
+        lastFetchedCount: statuses.count,
+        pageLimit: Constants.initialPageLimit)
+      if lastCount != statuses.count {
+        await cache()
+        await updateStatusesStateWithAnimation()
+      }
 
       // If we got 40 or more statuses, there might be older ones - create a gap
-      if statuses.count >= 40, let oldestStatus = statuses.last, !datasourceIsEmpty {
-        await createGapForOlderStatuses(maxId: oldestStatus.id, at: statuses.count)
+      if lastCount >= Constants.nextPageLimit, !datasourceIsEmpty {
+        let allStatuses = await datasource.get()
+        if let oldestStatus = allStatuses.last {
+          await createGapForOlderStatuses(maxId: oldestStatus.id, at: allStatuses.count)
+        }
       }
     }
   }
@@ -421,9 +434,13 @@ extension TimelineViewModel: GapLoadingFetcher {
     await datasource.append(contentOf: newStatuses)
     StatusDataControllerProvider.shared.updateDataControllers(for: newStatuses, client: client)
 
+    let lastCount = await autoFetchNextPagesIfFilteredEmpty(
+      lastFetchedCount: newStatuses.count,
+      pageLimit: Constants.nextPageLimit)
+    await cache()
     statusesState = await .displayWithGaps(
       items: datasource.getFilteredItems(),
-      nextPageState: newStatuses.count < 20 ? .none : .hasNextPage)
+      nextPageState: lastCount < Constants.nextPageLimit ? .none : .hasNextPage)
   }
 
   func statusDidAppear(status: Status) {
@@ -527,6 +544,43 @@ extension TimelineViewModel: GapLoadingFetcher {
     }
   }
 
+  private func autoFetchNextPagesIfFilteredEmpty(
+    lastFetchedCount: Int,
+    pageLimit: Int
+  ) async -> Int {
+    guard lastFetchedCount >= pageLimit else { return lastFetchedCount }
+    guard await datasource.getFilteredItems().isEmpty else { return lastFetchedCount }
+    guard let client else { return lastFetchedCount }
+
+    var pagesLoaded = 0
+    var lastCount = lastFetchedCount
+
+    while pagesLoaded < Constants.emptyFilterAutoPageLimit,
+      lastCount >= Constants.nextPageLimit,
+      await datasource.getFilteredItems().isEmpty
+    {
+      let statuses = await datasource.get()
+      guard let lastId = statuses.last?.id else { break }
+      let newStatuses: [Status]
+      do {
+        newStatuses = try await statusFetcher.fetchNextPage(
+          client: client,
+          timeline: timeline,
+          lastId: lastId,
+          offset: statuses.count)
+      } catch {
+        break
+      }
+      guard !newStatuses.isEmpty else { break }
+      await datasource.append(contentOf: newStatuses)
+      StatusDataControllerProvider.shared.updateDataControllers(for: newStatuses, client: client)
+      lastCount = newStatuses.count
+      pagesLoaded += 1
+    }
+
+    return lastCount
+  }
+
   private func createGapForOlderStatuses(sinceId: String? = nil, maxId: String, at index: Int) async
   {
     guard !isFullTimelineFetchEnabled else { return }

Packages/Timeline/Tests/TimelineTests/MockTimelineStatusFetcher.swift

@@ -0,0 +1,43 @@
+import Models
+import NetworkClient
+
+@testable import Timeline
+
+actor MockTimelineStatusFetcher: TimelineStatusFetching {
+  private let firstPage: [Status]
+  private let nextPages: [[Status]]
+  private var nextPageCalls: Int = 0
+
+  init(firstPage: [Status], nextPages: [[Status]]) {
+    self.firstPage = firstPage
+    self.nextPages = nextPages
+  }
+
+  func fetchFirstPage(client: MastodonClient?, timeline: TimelineFilter) async throws -> [Status] {
+    firstPage
+  }
+
+  func fetchNewPages(
+    client: MastodonClient?,
+    timeline: TimelineFilter,
+    minId: String,
+    maxPages: Int
+  ) async throws -> [Status] {
+    []
+  }
+
+  func fetchNextPage(
+    client: MastodonClient?,
+    timeline: TimelineFilter,
+    lastId: String,
+    offset: Int
+  ) async throws -> [Status] {
+    defer { nextPageCalls += 1 }
+    guard nextPageCalls < nextPages.count else { return [] }
+    return nextPages[nextPageCalls]
+  }
+
+  func nextPageCallCount() -> Int {
+    nextPageCalls
+  }
+}

Packages/Timeline/Tests/TimelineTests/TimelineTestFactories.swift

@@ -0,0 +1,56 @@
+import Foundation
+import Models
+
+func makeStatus(id: String, hidden: Bool) -> Status {
+  let base = Status.placeholder()
+  let filtered: [Filtered]? = hidden ? [makeHiddenFilter()].compactMap { $0 } : nil
+
+  return Status(
+    id: id,
+    content: base.content,
+    account: base.account,
+    createdAt: base.createdAt,
+    editedAt: base.editedAt,
+    reblog: base.reblog,
+    mediaAttachments: base.mediaAttachments,
+    mentions: base.mentions,
+    repliesCount: base.repliesCount,
+    reblogsCount: base.reblogsCount,
+    favouritesCount: base.favouritesCount,
+    card: base.card,
+    favourited: base.favourited,
+    reblogged: base.reblogged,
+    pinned: base.pinned,
+    bookmarked: base.bookmarked,
+    emojis: base.emojis,
+    url: base.url,
+    application: base.application,
+    inReplyToId: base.inReplyToId,
+    inReplyToAccountId: base.inReplyToAccountId,
+    visibility: base.visibility,
+    poll: base.poll,
+    spoilerText: base.spoilerText,
+    filtered: filtered,
+    sensitive: base.sensitive,
+    language: base.language,
+    tags: base.tags,
+    quote: nil,
+    quotesCount: nil,
+    quoteApproval: nil)
+}
+
+private func makeHiddenFilter() -> Filtered? {
+  let json = """
+    {
+      "filter": {
+        "id": "filter",
+        "title": "Hidden",
+        "context": ["home"],
+        "filterAction": "hide"
+      },
+      "keywordMatches": null
+    }
+    """
+
+  return try? JSONDecoder().decode(Filtered.self, from: Data(json.utf8))
+}

Packages/Timeline/Tests/TimelineTests/TimelineViewModelTests.swift

@@ -106,4 +106,31 @@ struct Tests {
     #expect(count == 1)
     #expect(statuses.first?.content.asRawText == "test")
   }
+
+  @Test
+  func autoFetchesWhenFilteredStatusesAreEmpty() async throws {
+    let contentFilter = TimelineContentFilter.shared
+    contentFilter.showBoosts = true
+    contentFilter.showReplies = true
+    contentFilter.showThreads = true
+    contentFilter.showQuotePosts = true
+
+    let hiddenFirstPage = (0..<50).map { makeStatus(id: "hidden-first-\($0)", hidden: true) }
+    let hiddenSecondPage = (0..<40).map { makeStatus(id: "hidden-next-\($0)", hidden: true) }
+    let visibleThirdPage = [makeStatus(id: "visible-0", hidden: false)]
+
+    let fetcher = MockTimelineStatusFetcher(
+      firstPage: hiddenFirstPage,
+      nextPages: [hiddenSecondPage, visibleThirdPage])
+
+    let subject = TimelineViewModel(statusFetcher: fetcher)
+    subject.client = MastodonClient(server: "localhost")
+    await subject.reset()
+
+    await subject.fetchNewestStatuses(pullToRefresh: false)
+
+    let filteredItems = await subject.datasource.getFilteredItems()
+    #expect(!filteredItems.isEmpty)
+    #expect(await fetcher.nextPageCallCount() >= 2)
+  }
 }