fix: update integration_test.go to match server.New signature (version, commit args)

ios/LibNovelV2/ViewModels/LibraryViewModel.swift

@@ -0,0 +1,164 @@
+import Foundation
+
+// MARK: - LibraryViewModel
+// Loads library items and exposes filtered/sorted views for LibraryView.
+// Uses @Observable (iOS 17+).
+
+enum LibrarySortOrder: String, CaseIterable {
+    case recent   = "Recent"
+    case title    = "Title"
+    case author   = "Author"
+    case progress = "Progress"
+}
+
+enum LibraryReadingFilter: String, CaseIterable {
+    case all        = "All"
+    case inProgress = "In Progress"
+    case completed  = "Completed"
+}
+
+@Observable
+@MainActor
+final class LibraryViewModel {
+    // Raw data
+    var items: [LibraryItem] = []
+    var progressMap: [String: Int] = [:]  // slug -> last chapter read
+
+    // Filter & sort state
+    var sortOrder: LibrarySortOrder = .recent
+    var readingFilter: LibraryReadingFilter = .all
+    var selectedGenre: String = "All"
+
+    // UI state
+    var isLoading = false
+    var error: String?
+
+    // MARK: - Derived
+
+    var allGenres: [String] {
+        var seen = Set<String>()
+        var result: [String] = ["All"]
+        for item in items {
+            for genre in item.book.genres where !seen.contains(genre) {
+                seen.insert(genre)
+                result.append(genre)
+            }
+        }
+        return result
+    }
+
+    var filteredItems: [LibraryItem] {
+        var list = items
+
+        // Genre filter
+        if selectedGenre != "All" {
+            list = list.filter { $0.book.genres.contains(selectedGenre) }
+        }
+
+        // Reading filter
+        switch readingFilter {
+        case .all:
+            break
+        case .inProgress:
+            list = list.filter { item in
+                let ch = progressMap[item.book.slug] ?? item.lastChapter ?? 0
+                return ch > 0 && ch < item.book.totalChapters
+            }
+        case .completed:
+            list = list.filter { item in
+                let ch = progressMap[item.book.slug] ?? item.lastChapter ?? 0
+                return item.book.totalChapters > 0 && ch >= item.book.totalChapters
+            }
+        }
+
+        // Sort
+        switch sortOrder {
+        case .recent:
+            // server already returns newest-saved first; preserve order
+            break
+        case .title:
+            list.sort { $0.book.title.localizedCaseInsensitiveCompare($1.book.title) == .orderedAscending }
+        case .author:
+            list.sort { $0.book.author.localizedCaseInsensitiveCompare($1.book.author) == .orderedAscending }
+        case .progress:
+            list.sort { a, b in
+                let pa = progressFraction(for: a)
+                let pb = progressFraction(for: b)
+                return pa > pb
+            }
+        }
+
+        return list
+    }
+
+    // MARK: - Progress helpers
+
+    func lastChapter(for item: LibraryItem) -> Int {
+        progressMap[item.book.slug] ?? item.lastChapter ?? 0
+    }
+
+    func progressFraction(for item: LibraryItem) -> Double {
+        let total = item.book.totalChapters
+        guard total > 0 else { return 0 }
+        return Double(lastChapter(for: item)) / Double(total)
+    }
+
+    func progressPercent(for item: LibraryItem) -> String {
+        let fraction = progressFraction(for: item)
+        let pct = fraction * 100
+        if pct < 10 {
+            return String(format: "%.1f%%", pct)
+        } else {
+            return String(format: "%.0f%%", pct)
+        }
+    }
+
+    func isCompleted(for item: LibraryItem) -> Bool {
+        let total = item.book.totalChapters
+        guard total > 0 else { return false }
+        return lastChapter(for: item) >= total
+    }
+
+    // MARK: - Load
+
+    func load() async {
+        isLoading = true
+        error = nil
+        do {
+            async let libraryTask  = APIClient.shared.library()
+            async let progressTask = APIClient.shared.progress()
+
+            let (library, progressEntries) = try await (libraryTask, progressTask)
+            items = library
+            progressMap = Dictionary(uniqueKeysWithValues: progressEntries.map { ($0.slug, $0.chapter) })
+        } catch {
+            if !(error is CancellationError) {
+                self.error = error.localizedDescription
+            }
+        }
+        isLoading = false
+    }
+
+    // MARK: - Mutations
+
+    func removeFromLibrary(slug: String) async {
+        // Optimistic remove
+        items.removeAll { $0.book.slug == slug }
+        do {
+            try await APIClient.shared.unsaveBook(slug: slug)
+        } catch {
+            // Silently fail — user can pull-to-refresh to restore
+        }
+    }
+
+    func markFinished(item: LibraryItem) async {
+        let total = item.book.totalChapters
+        guard total > 0 else { return }
+        progressMap[item.book.slug] = total
+        do {
+            try await APIClient.shared.setProgress(slug: item.book.slug, chapter: total)
+        } catch {
+            // Silently fail
+        }
+    }
+}