Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205import Foundationimport ParcelCore
@MainActorfinal class MinimumResetTransaction { let bundleID: String? var previous: MinimumResetTransaction? var confirmed: [String: LearnedMinimumSize] = [:] var cleared = false
init(bundleID: String?, previous: MinimumResetTransaction?) { self.bundleID = bundleID self.previous = previous }
func includes(_ bundleID: String) -> Bool { self.bundleID == nil || self.bundleID == bundleID }}
enum MinimumPersistenceError: LocalizedError { case save(any Error) case reset(any Error)
var errorDescription: String? { switch self { case .save(let error): String( localized: "Could not save learned minimum sizes: \(error.localizedDescription)", table: "Minimums", bundle: .module) case .reset(let error): String( localized: "Could not reset learned minimum sizes: \(error.localizedDescription)", table: "Minimums", bundle: .module) } }}
extension ParcelEngine { func inheritedMinimum(_ minimum: LearnedMinimumSize?, for window: WindowID) -> LearnedMinimumSize? { guard let minimum, let accepted = acceptedReadbacks[window]?.last?.accepted, accepted.isValid, accepted.size.width > 0, accepted.size.height > 0 else { return minimum } // A sibling's constraint cannot override a size this window has already accepted. let size = Size( width: minimum.size.width <= accepted.size.width ? minimum.size.width : 0, height: minimum.size.height <= accepted.size.height ? minimum.size.height : 0) guard size.width > 0 || size.height > 0 else { return nil } return LearnedMinimumSize(size: size, schemaVersion: minimum.schemaVersion) }
func persistConfirmedMinimum(_ minimum: LearnedMinimumSize, for window: WindowID) { guard let bundleID = snapshot.state.windows[window]?.app.bundleID, !bundleID.isEmpty, !bundleID.contains(where: \.isWhitespace) else { return } var transaction = minimumResetInFlight var resets: [MinimumResetTransaction] = [] while let pending = transaction { if pending.includes(bundleID) { resets.append(pending) } transaction = pending.previous } guard minimumLearning.learned[bundleID] != minimum || !resets.isEmpty else { return } do { try minimumLearning.recordConfirmed(minimum, for: bundleID) for pending in resets { pending.confirmed[bundleID] = minimum } _ = scheduleMinimumSave() } catch { reportMinimumFailure(.save(error), underlying: error) } }
@discardableResult private func scheduleMinimumSave() -> Task<Result<Void, any Error>, Never>? { guard let store = minimumSizeStore else { return nil } let previous = minimumPersistence let task = Task { @MainActor in _ = await previous?.value // Read after the predecessor commits, so a queued save cannot restore a reset entry. let value = self.minimumLearning do { try await Task.detached { try store.save(value) }.value return Result<Void, any Error>.success(()) } catch { self.reportMinimumFailure(.save(error), underlying: error) return Result<Void, any Error>.failure(error) } } minimumPersistence = task return task }
/// Clears one app's learned and pending entries, or all apps', returning whether any were removed. @discardableResult public func resetLearnedMinimums(for bundleID: String? = nil) async throws -> Bool { let store = minimumSizeStore return try await resetLearnedMinimums(for: bundleID) { staged in guard let store else { return } try await Task.detached { if bundleID == nil, staged.learned.isEmpty { try store.reset() } else { try store.save(staged) } }.value } }
func resetLearnedMinimums( for bundleID: String?, persist: @escaping @Sendable (MinimumSizeLearning) async throws -> Void ) async throws -> Bool { if let bundleID, bundleID.isEmpty || bundleID.contains(where: \.isWhitespace) { throw MinimumSizeLearningError.invalidBundleID(bundleID) } let transaction = MinimumResetTransaction(bundleID: bundleID, previous: minimumResetInFlight) minimumResetInFlight = transaction let previous = minimumPersistence let task = Task { @MainActor in _ = await previous?.value defer { self.finishMinimumReset(transaction) } do { let staged = try self.minimumsAfterReset(transaction) try await persist(staged) // Confirmations received while disk I/O was suspended belong to the next learning pair. let committed = try self.minimumsAfterReset(transaction) transaction.cleared = self.minimumLearning.learned.keys.contains { committed.learned[$0] == nil } || self.minimumLearning.pending.keys.contains { committed.pending[$0] == nil } self.minimumLearning = committed self.clearMinimumReadbacks(for: bundleID) return Result<Void, any Error>.success(()) } catch { self.reportMinimumFailure(.reset(error), underlying: error) return Result<Void, any Error>.failure(error) } } minimumPersistence = task try await task.value.get() return transaction.cleared }
private func minimumsAfterReset(_ transaction: MinimumResetTransaction) throws -> MinimumSizeLearning { var value = minimumLearning if let bundleID = transaction.bundleID { value.reset(for: bundleID) } else { value.resetAll() } for (bundleID, minimum) in transaction.confirmed { try value.recordConfirmed(minimum, for: bundleID) } return value }
private func finishMinimumReset(_ transaction: MinimumResetTransaction) { if minimumResetInFlight === transaction { minimumResetInFlight = transaction.previous return } var pending = minimumResetInFlight while let current = pending { if current.previous === transaction { current.previous = transaction.previous return } pending = current.previous } preconditionFailure("Minimum reset transaction left its persistence queue") }
private func reportMinimumFailure(_ failure: MinimumPersistenceError, underlying error: any Error) { log.record(.internalFailure(error)) onFailure?(failure) }
private func clearMinimumReadbacks(for bundleID: String?) { let windows = snapshot.state.windows.values.filter { bundleID == nil || $0.app.bundleID == bundleID } let ids = Set(windows.map(\.id)) queue.removeAll { pending in if case .minimumSizeChanged(let id, _) = pending.event { return ids.contains(id) } return false } var state = snapshot.state for window in windows { // Retire old read-backs before a new resize can start another confirmation pair. cancelMotion(window.id, remove: false) minimumCandidates[window.id] = nil deferredResizeMinimums[window.id] = nil frameAdjustments[window.id] = nil frameWriteDiagnostics[window.id] = nil acceptedReadbacks[window.id] = nil pendingSizeFitResets.insert(window.id) correctiveWrites[window.id] = nil blockedWindows.remove(window.id) let native = window.facts?.minimumSize ?? observations[window.id]?.window.minimumSize let minimum = minimumLearning.learned[window.app.bundleID] ?? native.map { LearnedMinimumSize(size: $0) } if isRunning { enqueue(.minimumSizeChanged(window.id, minimum: minimum)) } else { state.windows[window.id]?.minimum = minimum } } if !isRunning { snapshot = EngineSnapshot(revision: snapshot.revision, state: state) } }}