fix: compress large folders without freezing the app (#278)

Config/products/macpacker.json

@@ -36,8 +36,33 @@
     },
     "versions": [
       {
-        "version": "1.0.1",
+        "version": "1.1.0",
         "items": [
+          {
+            "type": "feat",
+            "highlight": true,
+            "title": {
+                "en": "Progress window when compressing from Finder",
+                "zh-Hans": "从 Finder 压缩时显示进度窗口",
+                "fr": "Fenêtre de progression pour la compression depuis le Finder",
+                "de": "Fortschrittsfenster beim Komprimieren im Finder",
+                "it": "Finestra di avanzamento per la compressione dal Finder",
+                "ja": "Finder からの圧縮に進行状況ウィンドウを表示",
+                "fa": "پنجره پیشرفت هنگام فشرده‌سازی از Finder",
+                "pl": "Okno postępu przy kompresowaniu z Findera",
+                "pt-BR": "Janela de progresso ao comprimir pelo Finder",
+                "ru": "Окно хода сжатия из Finder",
+                "uk": "Вікно перебігу стиснення з Finder",
+                "es-MX": "Ventana de progreso al comprimir desde el Finder",
+                "ko": "Finder에서 압축할 때 진행 창 표시",
+                "nl": "Voortgangsvenster bij comprimeren in de Finder",
+                "tr": "Finder’dan sıkıştırırken ilerleme penceresi",
+                "vi": "Cửa sổ tiến trình khi nén từ Finder"
+            },
+            "issues": [
+                "278"
+            ]
+          },
           {
             "type": "fix",
             "highlight": true,
@@ -62,6 +87,31 @@
             "issues": [
                 "278"
             ]
+          },
+          {
+            "type": "fix",
+            "highlight": true,
+            "title": {
+                "en": "Compressing a large folder freezes the app",
+                "zh-Hans": "压缩大型文件夹会导致应用程序冻结",
+                "fr": "Compresser un gros dossier bloque l’application",
+                "de": "Großen Ordner komprimieren lässt die App einfrieren",
+                "it": "Comprimere una cartella grande blocca l’applicazione",
+                "ja": "大きなフォルダを圧縮するとアプリがフリーズする",
+                "fa": "فشرده‌سازی پوشه بزرگ باعث توقف برنامه می‌شود",
+                "pl": "Kompresowanie dużego folderu zawiesza aplikację",
+                "pt-BR": "Comprimir uma pasta grande faz o aplicativo travar",
+                "ru": "Сжатие большой папки приводит к зависанию приложения",
+                "uk": "Стиснення великої папки призводить до зависання застосунку",
+                "es-MX": "Comprimir una carpeta grande congela la aplicación",
+                "ko": "큰 폴더를 압축하면 앱이 멈춤",
+                "nl": "Een grote map comprimeren laat de app vastlopen",
+                "tr": "Büyük bir klasörü sıkıştırmak uygulamayı donduruyor",
+                "vi": "Nén thư mục lớn làm ứng dụng bị treo"
+            },
+            "issues": [
+                "278"
+            ]
           }
         ]
       },

MacPacker/AppDelegate.swift

@@ -271,31 +271,47 @@ final class AppDelegate: NSObject, NSApplicationDelegate, ObservableObject {
     }
 
     /// Asked for in #119: don't let the app quit silently while an
-    /// extraction is running.
+    /// extraction is running. Nor while Finder's compress is, which has no
+    /// window that would say so.
     public func applicationShouldTerminate(_ sender: NSApplication) -> NSApplication.TerminateReply {
 #if DEBUG
         // The extraction demo keeps a job "active" on purpose; don't let the
         // quit-guard alert block the relaunches that drive its screenshots.
         if ExtractionDemo.isRequested { return .terminateNow }
 #endif
-        guard ExtractionProgressCenter.shared.hasActiveJobs else {
+        guard let running = ExtractionProgressCenter.shared.runningKind else {
             return .terminateNow
         }
 
-        log.notice("Quit requested while extraction is running — asking user")
+        // "extraction" / "compression": the lines an extraction always logged, as they were
+        let what = running == .extraction ? "extraction" : "compression"
+        log.notice("Quit requested while \(what) is running — asking user")
         let alert = NSAlert()
         alert.alertStyle = .warning
-        alert.messageText = String(localized: .appExtractionInProgress)
-        alert.informativeText = String(localized: .appQuitDuringExtractionWarning)
+        switch running {
+        case .extraction:
+            alert.messageText = String(localized: .appExtractionInProgress)
+            alert.informativeText = String(localized: .appQuitDuringExtractionWarning)
+        case .compression:
+            alert.messageText = String(localized: .appCompressionInProgress)
+            alert.informativeText = String(localized: .appQuitDuringCompressionWarning)
+        }
         alert.addButton(withTitle: String(localized: .commonCancel))
         alert.addButton(withTitle: String(localized: .appQuitAnyway))
 
         if alert.runModal() == .alertFirstButtonReturn {
-            log.notice("Quit cancelled — extraction continues")
+            log.notice("Quit cancelled — \(what) continues")
             return .terminateCancel
         }
-        log.notice("Quit forced during extraction")
-        return .terminateNow
+        log.notice("Quit forced during \(what)")
+        // What is being compressed is stopped first, and the quit waits for it:
+        // the writer then removes what it had written. Quit under it, and half
+        // an archive stays behind under the name the whole one was to have.
+        Task { @MainActor in
+            await ExtractionProgressCenter.shared.cancelAll(.compression, waitingUpTo: .seconds(5))
+            NSApp.reply(toApplicationShouldTerminate: true)
+        }
+        return .terminateLater
     }
 
     public func applicationWillTerminate(_ notification: Notification) {

MacPacker/Core/UrlHandling/AppUrlCompressHandler.swift

@@ -15,6 +15,10 @@ private let log = tb.Logger(subsystem: "app.MacPacker", category: "url")
 
 /// Writes `items` into a new archive at `destination` through the same
 /// add/save path the UI uses; the format follows the destination's extension.
+///
+/// There is no window to show it in, so it goes to the progress window: that
+/// comes up once the compress takes long enough, can cancel it, and stays up
+/// to say why it failed.
 /// - Returns: whether the archive was written.
 @MainActor
 private func writeArchive(
@@ -25,10 +29,12 @@ private func writeArchive(
 ) async -> Bool {
     log.notice("Compressing \(items.count) item(s) to \(destination.lastPathComponent)")
     let state = ArchiveState(catalog: catalog, engineSelector: engineSelector)
-    await state.compress(items, to: destination)
-
-    if let error = state.error {
-        log.error("Compress failed", context: ["error": error])
+    guard await state.compress(items, to: destination, showingProgress: true) else {
+        if let error = state.error {
+            log.error("Compress failed", context: ["error": error])
+        } else {
+            log.notice("Compress cancelled", context: ["file": destination.lastPathComponent])
+        }
         return false
     }
     log.notice("Compress done", context: ["file": destination.lastPathComponent])

MacPacker/Features/ArchiveContentViewer/ArchiveContentToolbarView.swift

@@ -39,9 +39,7 @@ struct ArchiveContentToolbarView: ToolbarContent {
         panel.begin { response in
             guard response == .OK else { return }
             Task { @MainActor in
-                for url in panel.urls {
-                    state.add(url: url)
-                }
+                state.add(urls: panel.urls)
             }
         }
     }

MacPacker/Features/ArchiveContentViewer/ArchiveView.swift

@@ -130,6 +130,17 @@ struct ArchiveView: View {
             "zone": zone.name
         ])
 
+        // One drop is one add, however many files it holds. Added file by file,
+        // each was read, put into the archive and shown on its own: a thousand
+        // files, a thousand times over.
+        if zone == .add {
+            loadDroppedFileURLs(from: providers) { urls in
+                log.notice("Drop → add to current archive", context: ["files": "\(urls.count)"])
+                state.add(urls: urls)
+            }
+            return
+        }
+
         for provider in providers {
             provider.loadItem(forTypeIdentifier: UTType.fileURL.identifier, options: nil) { data, _ in
                 guard let data = data as? Data,
@@ -138,15 +149,11 @@ struct ArchiveView: View {
                     return
                 }
                 Task { @MainActor in
-                    switch zone {
-                    case .add:
-                        log.notice("Drop → add to current archive", context: ["file": url.lastPathComponent])
-                        state.add(url: url)
-                    case .open where state.hasArchive:
+                    if state.hasArchive {
                         // This window is taken (and may hold unsaved edits).
                         log.notice("Drop → open in a new window", context: ["file": url.lastPathComponent])
                         openInNewWindowAction(url)
-                    case .open:
+                    } else {
                         log.notice("Drop → open in this window", context: ["file": url.lastPathComponent])
                         if state.isSupportedArchive(url: url) { RecentArchives.note(url) }
                         state.openDropped(url: url)

MacPacker/Features/ArchiveWindow/ArchiveWindowManager.swift

@@ -138,8 +138,8 @@ class ArchiveWindowManager {
     func openCreateArchiveWindow(with files: [URL] = []) -> ArchiveState {
         let state = createAndShowArchiveWindow(nil)
         state.create(named: String(localized: .commonNewArchive))
-        for file in files {
-            state.add(url: file)
+        if !files.isEmpty {
+            state.add(urls: files)
         }
         return state
     }

MacPacker/Features/DropWindow/CompressSettings.swift

@@ -76,7 +76,8 @@ struct CompressPinButton: View {
     }
 }
 
-/// The urls of one drop, handed over together — one drop is one archive.
+/// The urls of one drop, handed over together — one drop is one archive, or one
+/// add to the archive a window shows.
 ///
 /// `loadItem` must be *started* inside the drop callback: the providers belong to
 /// the drag session and are unreliable once it ends. The answers arrive later, out

MacPacker/Features/ExtractionProgress/ExtractionProgressWindowController.swift

@@ -13,10 +13,10 @@ import tb
 
 private let log = tb.Logger(subsystem: "app.MacPacker", category: "extraction")
 
-/// Owns the extraction progress window. It observes the shared
+/// Owns the progress window. It observes the shared
 /// `ExtractionProgressCenter` and
 /// - shows itself as soon as a job is running (also for window-less flows
-///   like the Finder extension's "Extract here"),
+///   like the Finder extension's "Extract here" and "Compress to …"),
 /// - closes itself shortly after all jobs finished successfully,
 /// - stays open when a job failed so the error remains visible.
 @MainActor
@@ -103,6 +103,12 @@ final class ExtractionProgressWindowController: NSWindowController, NSWindowDele
 
 
         if hasActive {
+            // Named after what is running. The title bar shows no text; VoiceOver
+            // and Mission Control read it.
+            let title = String(localized: center.runningKind == .compression ? .commonCompressing : .commonExtracting)
+            if window?.title != title {
+                window?.title = title
+            }
             scheduledClose?.cancel()
             scheduledClose = nil
             scheduleShowIfNeeded()

MacPacker/Features/LaunchParameters/LaunchParameters.swift

@@ -239,6 +239,8 @@ enum LaunchParameters {
         _ state: ArchiveState, navigate: String?, add: [URL], search: String?, select: String?
     ) async {
         try? await state.openTask?.value
+        // what a new archive was opened with is read off the main actor
+        _ = await state.addTask?.value
 
         if let navigate, !navigate.isEmpty {
             for segment in navigate.split(separator: "/").map(String.init) {
@@ -250,8 +252,8 @@ enum LaunchParameters {
             }
         }
 
-        for file in add {
-            state.add(url: file)
+        if !add.isEmpty {
+            _ = await state.add(urls: add).value
         }
 
         if let search, !search.isEmpty {

MacPacker/Localizable.xcstrings

@@ -1,6 +1,18 @@
 {
   "sourceLanguage": "en",
   "strings": {
+    "appCompressionInProgress": {
+      "comment": "Title of the alert shown when the user quits while Finder's \"Compress to …\" is still writing an archive.",
+      "extractionState": "manual",
+      "localizations": {
+        "en": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "A compression is still in progress"
+          }
+        }
+      }
+    },
     "appExtractionInProgress": {
       "comment": "Title of the alert shown when the user quits while an extraction is running.",
       "extractionState": "manual",
@@ -217,6 +229,18 @@
         }
       }
     },
+    "appQuitDuringCompressionWarning": {
+      "comment": "Body of the alert shown when the user quits while Finder's \"Compress to …\" is still writing an archive. Quitting cancels it and removes what was written so far.",
+      "extractionState": "manual",
+      "localizations": {
+        "en": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Quitting stops the compression."
+          }
+        }
+      }
+    },
     "appQuitDuringExtractionWarning": {
       "comment": "Body of the alert shown when the user quits while an extraction is running.",
       "extractionState": "manual",
@@ -6585,6 +6609,18 @@
         }
       }
     },
+    "commonCompressing": {
+      "comment": "Name of the progress window while it shows an archive being written from Finder's \"Compress to …\". The title bar shows no text; VoiceOver and Mission Control read it.",
+      "extractionState": "manual",
+      "localizations": {
+        "en": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Compressing"
+          }
+        }
+      }
+    },
     "commonCompression": {
       "comment": "Label of the compression level picker in the archive options",
       "extractionState": "manual",

Modules/Sources/Core/ArchiveSaver.swift

@@ -43,8 +43,11 @@ final actor ArchiveSaver {
     private let sourcePassword: String?
     private let passwordResolver: ArchivePasswordResolver
     private let folderAccessProvider: ArchiveFolderAccessUserProvider?
-    /// Percent written, on the main actor.
-    private let onProgress: @MainActor @Sendable (Int) -> Void
+    /// Bytes written, of how many, and when 7-Zip said so — on the main actor.
+    private let onProgress: @MainActor @Sendable (_ completed: UInt64, _ total: UInt64, _ at: Date) -> Void
+    /// Set to stop the write. 7-Zip is told at its next progress report, and
+    /// removes what it had written.
+    private let cancel: ExtractionCancelFlag?
 
     /// How often the source's password is asked for before the save gives up.
     static let passwordPrompts = 5
@@ -60,7 +63,8 @@ final actor ArchiveSaver {
         sourcePassword: String?,
         passwordResolver: @escaping ArchivePasswordResolver,
         folderAccessProvider: ArchiveFolderAccessUserProvider?,
-        onProgress: @escaping @MainActor @Sendable (Int) -> Void
+        onProgress: @escaping @MainActor @Sendable (_ completed: UInt64, _ total: UInt64, _ at: Date) -> Void,
+        cancel: ExtractionCancelFlag? = nil
     ) {
         self.source = source
         self.splitArchiveName = splitArchiveName
@@ -73,6 +77,7 @@ final actor ArchiveSaver {
         self.passwordResolver = passwordResolver
         self.folderAccessProvider = folderAccessProvider
         self.onProgress = onProgress
+        self.cancel = cancel
     }
 
     func save() async throws -> Saved {
@@ -178,20 +183,21 @@ final actor ArchiveSaver {
         }
     }
 
-    /// 7-Zip's byte progress as a percentage. The callback fires on the writing
-    /// (GCD) thread: throttled, then passed to the main actor.
+    /// 7-Zip's byte progress. The callback fires on the writing (GCD) thread:
+    /// throttled, then passed to the main actor with the time it was emitted —
+    /// reports reach the main queue in bursts, and speed is worked out from how
+    /// far apart they really were. What it returns is whether to go on.
     private func progressHandler() -> @Sendable (UInt64, UInt64) -> Bool {
         let throttle = ProgressThrottle()
-        let onProgress = onProgress
+        let (onProgress, cancel) = (onProgress, cancel)
         return { completed, total in
-            guard total > 0 else { return true }
-            let percent = Int((completed * 100) / total)
-            if throttle.shouldEmit(at: Date()) {
+            let now = Date()
+            if total > 0, throttle.shouldEmit(at: now) {
                 DispatchQueue.main.async {
-                    MainActor.assumeIsolated { onProgress(percent) }
+                    MainActor.assumeIsolated { onProgress(completed, total, now) }
                 }
             }
-            return true
+            return cancel?.isCancelled != true
         }
     }