fix: FilesViewModel - WPB-24805

WireMessaging/Sources/WireMessagingAssembly/WireMessagingFactory.swift

@@ -162,9 +162,9 @@ public extension WireMessagingFactory {
                 localAssetRepository: localAssetRepository,
                 nodeCache: nodeCache,
                 nodeRenameNotifier: nodeRenameNotifier,
-                fileCache: fileCache,
-                accentColorProvider: accentColorProvider
-            ).environment(\.wireAccentColor, accentColorProvider())
+                fileCache: fileCache
+            )
+            .environment(\.wireAccentColor, accentColorProvider())
         )
     }
 
@@ -216,6 +216,7 @@ public extension WireMessagingFactory {
                         updatePublicLinkExpiration: WireDriveUpdatePublicLinkExpirationUseCase(nodesAPI: nodesAPI),
                         updatePublicLinkPassword: WireDriveUpdatePublicLinkPasswordUseCase(nodesAPI: nodesAPI),
                         getDriveConversations: WireDriveGetConversationsUseCase(nodesAPI: nodesAPI),
+                        getFileTemplates: WireDriveFetchFileTemplatesUseCase(repository: nodesAPI),
                         makeAssetAvailableOffline: WireDriveMakeAssetAvailableOfflineUseCase(
                             localAssetRepository: localAssetRepository
                         ),
@@ -229,11 +230,10 @@ public extension WireMessagingFactory {
                     isCellsStatePending: false,
                     localAssetRepository: localAssetRepository,
                     nodesRepository: nodesAPI,
-                    fileCache: fileCache,
-                    isBrowsing: true,
-                    accentColorProvider: accentColorProvider
+                    isBrowsing: true
                 )
-            ).environment(\.wireAccentColor, accentColorProvider())
+            )
+            .environment(\.wireAccentColor, accentColorProvider())
         )
     }
 

WireMessaging/Sources/WireMessagingDomain/WireDrive/UseCases/WireDriveCreateFileUseCase.swift

@@ -27,9 +27,18 @@ package enum WireDriveCreateFileUseCaseError: Error {
 /// Creates a file or a folder on the server.
 package struct WireDriveCreateFileUseCase: WireDriveCreateFileUseCaseProtocol {
 
-    package enum Target: Equatable {
+    package enum Target: Equatable, Identifiable {
         case folder
         case file(WireDriveFileTemplate)
+
+        package var id: String {
+            switch self {
+            case .folder:
+                "folder"
+            case let .file(template):
+                "file:\(template.id)"
+            }
+        }
     }
 
     private let nodesRepository: any WireDriveNodesRepositoryProtocol

WireMessaging/Sources/WireMessagingDomain/WireDrive/UseCases/WireDriveFetchFileTemplatesUseCase.swift

@@ -16,7 +16,7 @@
 // along with this program. If not, see http://www.gnu.org/licenses/.
 //
 
-package import Foundation
+import Foundation
 
 /// Fetches templates useable for document creation (.docx, .pptx, .xlsx. etc)
 package struct WireDriveFetchFileTemplatesUseCase: WireDriveFetchFileTemplatesUseCaseProtocol {
@@ -30,7 +30,28 @@
     }
 
     package func invoke() async throws -> [WireDriveFileTemplate] {
-        try await repository.getTemplates()
+        // TODO: [WPB-22926] Replace hard coded values with server values when GET/ templates endpoint ready.
+        // Do `try await repository.getTemplates()`
+        [
+            .init(
+                kind: .document,
+                editable: true,
+                label: "Microsoft Word",
+                id: "01-Microsoft Word.docx"
+            ),
+            .init(
+                kind: .spreadsheet,
+                editable: true,
+                label: "Microsoft Excel",
+                id: "02-Microsoft Excel.xlsx"
+            ),
+            .init(
+                kind: .presentation,
+                editable: true,
+                label: "Microsoft PowerPoint",
+                id: "03-Microsoft PowerPoint.pptx"
+            )
+        ]
     }
 
 }

WireMessaging/Sources/WireMessagingUI/WireDrive/Components/Common/FilesListLoader.swift

@@ -0,0 +1,115 @@
+//
+// Wire
+// Copyright (C) 2026 Wire Swiss GmbH
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see http://www.gnu.org/licenses/.
+//
+
+import Combine
+import Foundation
+import Observation
+import WireLogging
+
+/// Loads and manages a paginated list of `FilesViewItem` elements.
+@MainActor
+class FilesListLoader: Observable, ObservableObject {
+    typealias Loader = IncrementalListLoader<FilesViewItem>
+
+    @Published private(set) var networkMonitor: NetworkMonitor
+    @Published private(set) var loader: Loader
+
+    var onFetchOnlineFiles: ((Int) async throws -> (items: [FilesViewItem], isLastPage: Bool))?
+    var onFetchOfflineFiles: (() async throws -> [FilesViewItem])?
+    var onErrorToPresent: ((any Error) -> Void)?
+
+    init(networkMonitor: NetworkMonitor = .shared) {
+        self.networkMonitor = networkMonitor
+
+        self.loader = .init()
+        loader.onFetch = { [weak self] offset in
+            guard let self else { return (items: [], isLastPage: true) }
+
+            if isOffline {
+                let items = try await onFetchOfflineFiles?() ?? []
+                return (items: items, isLastPage: true)
+            } else {
+                let (items, isLastPage) = try await onFetchOnlineFiles?(offset) ?? ([], true)
+                return (items: items.latestModified(), isLastPage: isLastPage)
+            }
+        }
+        loader.onError = { [weak self] error in
+            guard let self else { return }
+
+            if isOffline {
+                WireLogger.wireDrive.error("Error fetching offline assets:\n\(error)")
+                onErrorToPresent?(error)
+            } else {
+                if loader.state.items.isEmpty {
+                    loader.state = .error(isConnectionError: error.isNoInternetError)
+                } else {
+                    if !error.isNoInternetError {
+                        WireLogger.wireDrive.error("Error fetching online files:\n\(error)")
+                        onErrorToPresent?(error)
+                    }
+                }
+            }
+        }
+    }
+
+    private var isOffline: Bool {
+        networkMonitor.currentStatus == .disconnected
+    }
+
+    /// Removes an item from the list, then performs an async action.
+    /// If the action fails, restores the list to how it was before removing the item.
+    func removeItem(_ item: FilesViewItem, withAction action: @escaping () async throws -> Void) async {
+        let items = loader.state.items
+        let changedItems = items.filter { $0.id != item.id }
+        loader.state = .received(items: changedItems)
+
+        do {
+            try await action()
+        } catch {
+            guard loader.state.isLoaded else { return }
+
+            // set items to how they were before the change:
+            loader.state = .received(items: items)
+        }
+    }
+}
+
+private extension Collection<FilesViewItem> {
+    /// Removes items with duplicate IDs keeping the latest modified if known, otherwise the first.
+    func latestModified() -> [FilesViewItem] {
+        var latestByID: [UUID: FilesViewItem] = [:]
+        for item in self {
+            if let existing = latestByID[item.id] {
+                let existingDate = existing.modifiedAt ?? .distantPast
+                let newDate = item.modifiedAt ?? .distantPast
+                if newDate > existingDate {
+                    latestByID[item.id] = item
+                }
+            } else {
+                latestByID[item.id] = item
+            }
+        }
+
+        var results: [FilesViewItem] = []
+        for item in self where item == latestByID[item.id] {
+            results.append(item)
+        }
+
+        return results
+    }
+}

WireMessaging/Sources/WireMessagingUI/WireDrive/Components/Common/IncrementalListLoader.swift

@@ -0,0 +1,136 @@
+//
+// Wire
+// Copyright (C) 2026 Wire Swiss GmbH
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see http://www.gnu.org/licenses/.
+//
+
+import Combine
+import Observation
+
+/// A generic loader for paginated lists of items.
+@MainActor
+class IncrementalListLoader<Item: Identifiable & Hashable & Sendable>: Observable, ObservableObject {
+    private typealias LoadTask = Task<(items: [Item], isLastPage: Bool), any Error>
+    typealias ItemsData = (items: [Item], isLastPage: Bool)
+
+    enum State: Hashable {
+        case loading
+        case received(items: [Item])
+        case pending
+        case error(isConnectionError: Bool)
+
+        var items: [Item] {
+            switch self {
+            case let .received(items):
+                items
+            default:
+                []
+            }
+        }
+
+        var isLoaded: Bool {
+            switch self {
+            case .loading, .pending, .error:
+                false
+            case .received:
+                true
+            }
+        }
+    }
+
+    /// How close to the end of the list before loading more items.
+    var loadMoreThreshold = 5
+
+    @Published var state: State = .pending
+    @Published var hasMore = true
+
+    private var loadTask: LoadTask?
+
+    var onFetch: ((Int) async throws -> ItemsData)?
+    var onError: ((any Error) -> Void)?
+
+    /// Reloads the items, clearing any previously loaded items.
+    /// - Parameters:
+    ///   - refreshing: Whether the reload was triggered by a pull-to-refresh action.
+    ///
+    /// Cancels any ongoing load operation and starts a new one.
+    /// When `refreshing` is `true`, the current state is preserved since loading is managed by the system.
+    func reload(refreshing: Bool = false) async {
+        cancelLoad()
+        state = refreshing ? state : .loading
+        hasMore = !refreshing
+
+        await loadMore(refreshing: refreshing)
+    }
+
+    /// Loads more items if available and `index` is towards the end of the list.
+    ///
+    /// This method checks if the `index` is within the threshold for loading more items. For example given a threshold
+    /// of 5, when 10 items are loaded, it will load more when the index is 5 or above - i.e. when one of the last 5
+    /// items is being displayed.
+    ///
+    /// - Parameter index: The index of the item which requested load more.
+    func loadMoreIfNeeded(index: Int) async {
+        let remaining = state.items.count - index - 1
+        if remaining < loadMoreThreshold, hasMore {
+            await loadMore()
+        }
+    }
+
+    var isLoading: Bool {
+        loadTask != nil
+    }
+}
+
+private extension IncrementalListLoader {
+    func cancelLoad() {
+        loadTask?.cancel()
+        loadTask = nil
+    }
+
+    func loadMore(refreshing: Bool = false) async {
+        guard loadTask == nil else { return }
+
+        let offset = refreshing ? 0 : state.items.count
+        let task = Task {
+            try await fetchItems(offset: offset)
+        }
+
+        loadTask = task
+        defer { loadTask = nil }
+
+        do {
+            let (newItems, isLastPage) = try await task.value
+            let receivedItems = refreshing ? newItems : state.items + newItems
+            state = .received(items: receivedItems)
+            hasMore = !isLastPage
+        } catch is CancellationError {
+            return // developer-driven error, discard
+        } catch {
+            hasMore = state.items.isEmpty ? true : hasMore
+            onError?(error)
+        }
+    }
+
+    func fetchItems(offset: Int) async throws -> ItemsData {
+        if let onFetch {
+            let itemsData = try await onFetch(offset)
+            try Task.checkCancellation()
+            return itemsData
+        } else {
+            return (items: [], isLastPage: true)
+        }
+    }
+}

WireMessaging/Sources/WireMessagingUI/WireDrive/Components/Files/Create/CreateFileViewModel.swift

@@ -31,7 +31,8 @@ final class CreateFileViewModel: ObservableObject {
     @Published var errorMessage: String?
     @Published var isLoading: Bool = false
     @Published var isFocused: Bool = true
-    @Published var createdNode: WireDriveNode?
+
+    let onNodeCreated: (WireDriveNode) -> Void
 
     var isCreateDisabled: Bool {
         errorMessage != nil || !isInputValid
@@ -107,10 +108,12 @@ final class CreateFileViewModel: ObservableObject {
         creationTarget: WireDriveCreateFileUseCase.Target,
         path: String,
         createFileUseCase: any WireDriveCreateFileUseCaseProtocol,
+        onNodeCreated: @escaping (WireDriveNode) -> Void
     ) {
         self.creationTarget = creationTarget
         self.createFileUseCase = createFileUseCase
         self.path = path
+        self.onNodeCreated = onNodeCreated
 
         bindTextInput()
     }
@@ -121,12 +124,14 @@ final class CreateFileViewModel: ObservableObject {
         do {
             isLoading = true
 
-            createdNode = try await createFileUseCase.invoke(
+            let createdNode = try await createFileUseCase.invoke(
                 creationTarget: creationTarget,
                 path: path,
                 name: nameInput.trimmingCharacters(in: .whitespacesAndNewlines)
             )
 
+            onNodeCreated(createdNode)
+
             isLoading = false
 
             return true

WireMessaging/Sources/WireMessagingUI/WireDrive/Components/Files/FileVersioning/FileVersionItemView.swift

@@ -28,7 +28,6 @@ private typealias Accessibility = L10n.Accessibility.Conversation.WireCells
 
 struct FileVersionItemView: View {
     @StateObject private var viewModel: FileVersionItemViewModel
-    @Environment(\.wireAccentColor) private var wireAccentColor
     @State private var showRestoreVersionAlert = false
 
     init(