Show thumbnails in Uploads rows

Expose the materialized temp file URL on PendingUpload and FailedUpload,
carry it through UploadRowItem, and render it with QLThumbnailGenerator in
place of the kind icon. The icon remains until materialization completes,
for failed rows without a retryable payload, and for kinds QuickLook
cannot preview.

Author: crazytonyli

Modules/Sources/WordPressMediaLibrary/Models/FailedUpload.swift

@@ -13,4 +13,7 @@ struct FailedUpload: Identifiable, Sendable {
     /// `MediaCreateParams` / temp file were never produced — the
     /// Uploads-screen row should offer Dismiss only.
     let isRetryable: Bool
+    /// Materialized temp file on disk; non-nil exactly when `isRetryable`
+    /// (both derive from the materialized payload surviving the failure).
+    let localFileURL: URL?
 }

Modules/Sources/WordPressMediaLibrary/Models/PendingUpload.swift

@@ -8,4 +8,7 @@ struct PendingUpload: Identifiable, Sendable {
     let displayName: String // basename of the temp file
     let kind: MediaKind // for icon + Uploads-row rendering
     let progress: Progress // bound to ProgressView directly
+    /// Materialized temp file on disk; nil until materialization completes.
+    /// Drives the Uploads-row thumbnail.
+    let localFileURL: URL?
 }

Modules/Sources/WordPressMediaLibrary/Upload/MediaUploader.swift

@@ -364,7 +364,8 @@ private struct InternalPending {
             id: id,
             displayName: materialized?.displayName ?? displayName,
             kind: materialized?.kind ?? kind,
-            progress: overallProgress
+            progress: overallProgress,
+            localFileURL: materialized?.tempFileURL
         )
     }
 }
@@ -382,7 +383,8 @@ private struct InternalFailed {
             displayName: materialized?.displayName ?? displayName,
             kind: materialized?.kind ?? kind,
             errorMessage: errorMessage,
-            isRetryable: materialized != nil
+            isRetryable: materialized != nil,
+            localFileURL: materialized?.tempFileURL
         )
     }
 }

Modules/Sources/WordPressMediaLibrary/Views/MediaLibraryViewModel.swift

@@ -36,6 +36,7 @@ final class MediaLibraryViewModel: ObservableObject {
         let id: UUID
         let displayName: String
         let kind: MediaKind
+        let localFileURL: URL?
         let mode: Mode
     }
 
@@ -139,13 +140,15 @@ final class MediaLibraryViewModel: ObservableObject {
                     id: p.id,
                     displayName: p.displayName,
                     kind: p.kind,
+                    localFileURL: p.localFileURL,
                     mode: .uploading(p.progress)
                 )
             case .failed(let f):
                 return UploadRowItem(
                     id: f.id,
                     displayName: f.displayName,
                     kind: f.kind,
+                    localFileURL: f.localFileURL,
                     mode: .failed(message: f.errorMessage, isRetryable: f.isRetryable)
                 )
             }

Modules/Sources/WordPressMediaLibrary/Views/UploadRow.swift

@@ -9,10 +9,17 @@ struct UploadRow: View {
 
     var body: some View {
         HStack(spacing: 12) {
-            Image(systemName: item.kind.systemImageName)
-                .font(.title3)
-                .foregroundStyle(.secondary)
-                .frame(width: 32, height: 32)
+            if let fileURL = item.localFileURL {
+                UploadThumbnailView(
+                    fileURL: fileURL,
+                    fallbackSystemImage: item.kind.systemImageName
+                )
+            } else {
+                Image(systemName: item.kind.systemImageName)
+                    .font(.title3)
+                    .foregroundStyle(.secondary)
+                    .frame(width: 44, height: 44)
+            }
 
             VStack(alignment: .leading, spacing: 4) {
                 Text(item.displayName)

Modules/Sources/WordPressMediaLibrary/Views/UploadThumbnailView.swift

@@ -0,0 +1,49 @@
+import QuickLookThumbnailing
+import SwiftUI
+
+/// QuickLook thumbnail for a local upload file. Falls back to the kind's
+/// SF Symbol until generation finishes, or permanently when QuickLook
+/// cannot preview the type (e.g. audio). Requesting only `.thumbnail`
+/// (never `.icon`) keeps that failure clean instead of yielding a generic
+/// system file icon. No caching: scroll-back regenerates, which is cheap
+/// for local files.
+struct UploadThumbnailView: View {
+    let fileURL: URL
+    let fallbackSystemImage: String
+
+    @Environment(\.displayScale) private var displayScale
+    @State private var thumbnail: UIImage?
+
+    var body: some View {
+        ZStack {
+            if let thumbnail {
+                Image(uiImage: thumbnail)
+                    .resizable()
+                    .aspectRatio(contentMode: .fill)
+            } else {
+                Image(systemName: fallbackSystemImage)
+                    .font(.title3)
+                    .foregroundStyle(.secondary)
+            }
+        }
+        .frame(width: 44, height: 44)
+        .clipShape(RoundedRectangle(cornerRadius: 8))
+        .task(id: fileURL) {
+            let request = QLThumbnailGenerator.Request(
+                fileAt: fileURL,
+                size: CGSize(width: 44, height: 44),
+                scale: displayScale,
+                representationTypes: .thumbnail
+            )
+            // Extract UIImage inside the completion handler so that only the
+            // Sendable UIImage crosses the concurrency boundary, not the
+            // non-Sendable QLThumbnailRepresentation.
+            let image: UIImage? = await withCheckedContinuation { continuation in
+                QLThumbnailGenerator.shared.generateBestRepresentation(for: request) { representation, _ in
+                    continuation.resume(returning: representation?.uiImage)
+                }
+            }
+            thumbnail = image
+        }
+    }
+}

Modules/Tests/WordPressMediaLibraryTests/MediaUploaderTests.swift

@@ -523,4 +523,83 @@ struct MediaUploaderTests {
         #expect(state.pending.isEmpty)
         #expect(state.failed.isEmpty, "transport cancellation should be silent, not failed")
     }
+
+    @Test("localFileURL is nil before materialization and set after")
+    func localFileURLAppearsAfterMaterialization() async throws {
+        let transport = BlockingFakeUploadTransport()
+        let mock = MockMaterializer()
+        let uploader = MediaUploader(
+            transport: transport,
+            materializer: mock,
+            filePickerContentTypes: [.content]
+        )
+
+        let pdfURL = try writeTempPDF()
+        defer { try? FileManager.default.removeItem(at: pdfURL.deletingLastPathComponent()) }
+
+        await uploader.enqueue(sources: [.file(pdfURL)])
+        await mock.waitForStart()
+
+        let before = await uploader.snapshot()
+        #expect(before.pending.first?.localFileURL == nil)
+
+        let realTemp = try writeTempFile(name: "materialized.bin", content: Data("payload".utf8))
+        defer { try? FileManager.default.removeItem(at: realTemp.deletingLastPathComponent()) }
+        let materialized = MaterializedUpload(
+            tempFileURL: realTemp,
+            params: MediaCreateParams(filePath: realTemp.path),
+            kind: .document,
+            displayName: realTemp.lastPathComponent
+        )
+        await mock.complete(with: .success(materialized))
+        try await Task.sleep(for: .milliseconds(50))
+
+        // Transport is still blocked, so the entry is pending with a file on disk.
+        let after = await uploader.snapshot()
+        #expect(after.pending.first?.localFileURL == realTemp)
+
+        await transport.unblock()
+    }
+
+    @Test("upload-stage failure keeps localFileURL on the retryable failed entry")
+    func uploadFailureKeepsLocalFileURL() async throws {
+        let transport = FakeUploadTransport()
+        await transport.setResponses([.failure(URLError(.timedOut))])
+        let uploader = MediaUploader(transport: transport, policy: makeAllowEverythingPolicy())
+
+        let sourceURL = try writeTempPDF(name: "fail.pdf")
+        defer { try? FileManager.default.removeItem(at: sourceURL.deletingLastPathComponent()) }
+
+        await uploader.enqueue(sources: [.file(sourceURL)])
+        try await Task.sleep(for: .milliseconds(200))
+
+        let state = await uploader.snapshot()
+        #expect(state.failed.count == 1)
+        #expect(state.failed[0].isRetryable)
+        #expect(state.failed[0].localFileURL != nil)
+    }
+
+    @Test("materialization failure yields no localFileURL")
+    func materializationFailureHasNoLocalFileURL() async throws {
+        let transport = FakeUploadTransport()
+        let mock = MockMaterializer()
+        let uploader = MediaUploader(
+            transport: transport,
+            materializer: mock,
+            filePickerContentTypes: [.content]
+        )
+
+        let pdfURL = try writeTempPDF()
+        defer { try? FileManager.default.removeItem(at: pdfURL.deletingLastPathComponent()) }
+
+        await uploader.enqueue(sources: [.file(pdfURL)])
+        await mock.waitForStart()
+        await mock.complete(with: .failure(URLError(.cannotOpenFile)))
+        try await Task.sleep(for: .milliseconds(50))
+
+        let state = await uploader.snapshot()
+        #expect(state.failed.count == 1)
+        #expect(!state.failed[0].isRetryable)
+        #expect(state.failed[0].localFileURL == nil)
+    }
 }