Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528import ParcelAnimationimport ParcelConfigimport ParcelCoreimport ParcelEngineimport ParcelPlatformimport Testing
let engineDisplay = DisplayID(rawValue: "00000000-0000-0000-0000-000000000001")let secondEngineDisplay = DisplayID(rawValue: "00000000-0000-0000-0000-000000000002")let engineSpace = SpaceID(rawValue: 1)let engineWorkspace = WorkspaceKey(display: engineDisplay, space: engineSpace)let engineApp = AppID(pid: 100, bundleID: "test.fixture")let secondEngineApp = AppID(pid: 200, bundleID: "test.second")let engineScreen = Rect(x: 0, y: 0, width: 1200, height: 800)let initialEngineFrame = Rect(x: 40, y: 60, width: 300, height: 200)
func engineWindow(_ id: UInt32, app: AppID = engineApp, floating: Bool = false, title: String = "Document") -> ManagedWindow{ ManagedWindow(id: WindowID(rawValue: id), app: app, title: title, isFloating: floating)}
func engineConfiguration(glide: Bool = false, layout: ConfigLayout = .columns) -> ParcelConfiguration { ParcelConfiguration( layout: LayoutConfiguration(global: LayoutValues(defaultLayout: layout, gaps: LayoutGaps(inner: 0, outer: 0))), motion: MotionConfiguration(transitions: glide ? .glide : .snap) )}
func engineInitialState(twoDisplays: Bool = false) -> State { let first = Display(id: engineDisplay, frame: engineScreen) if twoDisplays { let second = Display(id: secondEngineDisplay, frame: Rect(x: 1200, y: 0, width: 1200, height: 800)) return State( displays: [first, second], activeSpaces: [engineDisplay: engineSpace, secondEngineDisplay: SpaceID(rawValue: 2)]) } return State(displays: [first], activeSpaces: [engineDisplay: engineSpace])}
@MainActorfinal class ManualEngineClock: EngineClock { private var instant: Double = 10 var readStep: Double = 0 { didSet { precondition(readStep.isFinite && readStep >= 0) } } var now: Double { get { defer { instant += readStep } return instant } set { instant = newValue } }}
@MainActorfinal class ManualEngineCancellation: EngineCancellation { private(set) var isCancelled = false func cancel() { isCancelled = true }}
@MainActorfinal class ManualEngineScheduler: EngineScheduler { private struct Work { let identifier: Int let deadline: Double let cancellation: ManualEngineCancellation let action: @MainActor () -> Void }
private let clock: ManualEngineClock private var work: [Work] = [] private var nextIdentifier = 0 private(set) var scheduledCount = 0 var pendingCount: Int { work.filter { !$0.cancellation.isCancelled }.count } var readyCount: Int { work.filter { !$0.cancellation.isCancelled && $0.deadline <= clock.now }.count } var cancelledCount: Int { work.filter { $0.cancellation.isCancelled }.count } var nextDeadline: Double? { work.filter { !$0.cancellation.isCancelled }.map(\.deadline).min() }
init(clock: ManualEngineClock) { self.clock = clock }
func schedule(after delay: Double, _ action: @escaping @MainActor () -> Void) -> any EngineCancellation { precondition(delay.isFinite && delay >= 0) let cancellation = ManualEngineCancellation() nextIdentifier += 1 scheduledCount += 1 work.append( Work(identifier: nextIdentifier, deadline: clock.now + delay, cancellation: cancellation, action: action)) return cancellation }
func runReady(limit: Int = 1000) throws { var executed = 0 while let index = work.indices.filter({ !work[$0].cancellation.isCancelled && work[$0].deadline <= clock.now }) .min(by: { let lhs = work[$0] let rhs = work[$1] return lhs.deadline == rhs.deadline ? lhs.identifier < rhs.identifier : lhs.deadline < rhs.deadline }) { guard executed < limit else { throw HarnessError.schedulerDidNotQuiesce } let ready = work.remove(at: index) ready.action() executed += 1 } }
func advance(by interval: Double) throws { precondition(interval >= 0) clock.now += interval try runReady() }
func runNext() throws { guard let deadline = nextDeadline else { throw HarnessError.noScheduledWork } clock.now = max(clock.now, deadline) try runReady() }
func fireCancelledWork() { let cancelled = work.filter { $0.cancellation.isCancelled } work.removeAll { $0.cancellation.isCancelled } for item in cancelled { item.action() } }}
enum HarnessError: Error { case schedulerDidNotQuiesce case noScheduledWork case missingWrite case missingAction case missingConfigurationStart case startup}
@MainActorfinal class FakeEngineWorld: EngineWindowWorld, EngineCommandWindowProviding { var accessibilityPermissionGranted: Bool?
struct Behavior { var duration: Double = 0.001 var minimumSize: Size? var maximumSize: Size? var widthMultiple: Double? var roundsWidthUp = false var positionOffset = Point() var offsetWrites = Int.max var timesOut = false var vanishes = false var refusesFrames = false }
struct WriteRecord { let app: AppID let writes: [EngineFrameWrite] let at: Double }
private struct PendingWrite { let record: WriteRecord let completion: @MainActor (EngineWriteReceipt) -> Void }
private let clock: ManualEngineClock private var receive: (@MainActor (EnginePlatformEvent) -> Void)? private var retainedReceive: (@MainActor (EnginePlatformEvent) -> Void)? private var receivers: [@MainActor (EnginePlatformEvent) -> Void] = [] private var pendingWrites: [PendingWrite] = [] private var pendingActions: [@MainActor (EnginePlatformFailure?) -> Void] = [] var frames: [WindowID: Rect] = [:] var behaviors: [AppID: Behavior] = [:] var deferWrites = false var afterReceipt: (@MainActor ([EngineFrameWrite]) -> Void)? var deferActions = false var startError: HarnessError? var emitsEngineEchoes = false private(set) var writes: [WriteRecord] = [] private(set) var focused: [WindowID] = [] private(set) var raised: [WindowID] = [] private(set) var closed: [WindowID] = [] private(set) var fullscreenToggles: [WindowID] = [] var commandWindow: ManagedWindow? var commandWindowError: (any Error)? var commandError: (any Error)? var deferWindowCommands = false var onWindowCommandPending: (@MainActor () -> Void)? private var windowCommands: [CheckedContinuation<Void, any Error>] = [] var pendingWindowCommandCount: Int { windowCommands.count } private(set) var reconciliations: [Set<AppID>] = [] func reconcile(_ apps: Set<AppID>) { reconciliations.append(apps) } private(set) var allowsSpeculation = false private(set) var placementClassifier: WindowClassifier? func updatePlacementState(_ state: State, classifier: WindowClassifier?, allowsSpeculation: Bool) { self.allowsSpeculation = allowsSpeculation placementClassifier = classifier } private(set) var startCount = 0 private(set) var stopCount = 0 var pendingWriteCount: Int { pendingWrites.count } var pendingActionCount: Int { pendingActions.count } var allWrites: [EngineFrameWrite] { writes.flatMap(\.writes) }
init(clock: ManualEngineClock) { self.clock = clock }
func start(receive: @escaping @MainActor (EnginePlatformEvent) -> Void) throws { startCount += 1 if let startError { throw startError } self.receive = receive retainedReceive = receive receivers.append(receive) }
func stop() { stopCount += 1 receive = nil }
func emit(_ event: EnginePlatformEvent) { receive?(event) } func emitLate(_ event: EnginePlatformEvent) { retainedReceive?(event) } func emitFromStart(_ index: Int, event: EnginePlatformEvent) { receivers[index](event) }
func appear(_ window: ManagedWindow, workspace: WorkspaceKey = engineWorkspace, frame: Rect = initialEngineFrame) { frames[window.id] = frame emit(.observed(.windowAppeared(window, workspace: workspace, frame: frame))) }
func disappear(_ window: WindowID) { frames[window] = nil emit(.observed(.windowDisappeared(window))) }
func userFrame(_ window: WindowID, frame: Rect, resized: Bool = false, origin: FrameChangeOrigin = .user) { frames[window] = frame emit(.frameChanged(window, frame: frame, resized: resized, origin: origin)) }
func write( _ frames: [EngineFrameWrite], for app: AppID, completion: @escaping @MainActor (EngineWriteReceipt) -> Void ) { let record = WriteRecord(app: app, writes: frames, at: clock.now) writes.append(record) if deferWrites { pendingWrites.append(PendingWrite(record: record, completion: completion)) } else { completion(makeReceipt(record)) afterReceipt?(frames) } }
func focus(_ window: WindowID, completion: @escaping @MainActor (EnginePlatformFailure?) -> Void) { focused.append(window) completeAction(completion) }
func raise(_ window: WindowID, completion: @escaping @MainActor (EnginePlatformFailure?) -> Void) { raised.append(window) completeAction(completion) }
func focusedCommandWindow() async throws -> ManagedWindow? { if let commandWindowError { throw commandWindowError } return commandWindow }
func close(_ window: WindowID) async throws { closed.append(window) try await windowCommand() }
func toggleFullscreen(_ window: WindowID) async throws { fullscreenToggles.append(window) try await windowCommand() }
private func windowCommand() async throws { try Task.checkCancellation() if let commandError { throw commandError } if deferWindowCommands { try await withCheckedThrowingContinuation { windowCommands.append($0) onWindowCommandPending?() } } try Task.checkCancellation() }
func completeWindowCommand(error: (any Error)? = nil) throws { guard !windowCommands.isEmpty else { throw HarnessError.missingAction } let pending = windowCommands.removeFirst() if let error { pending.resume(throwing: error) } else { pending.resume() } }
func completeNextWrite(receipt: EngineWriteReceipt? = nil) throws { guard !pendingWrites.isEmpty else { throw HarnessError.missingWrite } let pending = pendingWrites.removeFirst() pending.completion(receipt ?? makeReceipt(pending.record)) afterReceipt?(pending.record.writes) }
func completeNextAction(failure: EnginePlatformFailure? = nil) throws { guard !pendingActions.isEmpty else { throw HarnessError.missingAction } pendingActions.removeFirst()(failure) }
func writes(for window: WindowID) -> [EngineFrameWrite] { allWrites.filter { $0.window == window } }
private func completeAction(_ completion: @escaping @MainActor (EnginePlatformFailure?) -> Void) { if deferActions { pendingActions.append(completion) } else { completion(nil) } }
private func makeReceipt(_ record: WriteRecord) -> EngineWriteReceipt { var behavior = behaviors[record.app] ?? Behavior() if behavior.vanishes { for write in record.writes { frames[write.window] = nil } return EngineWriteReceipt( frames: [], failures: record.writes.map { .vanished($0.window) }, duration: behavior.duration) } if behavior.timesOut { return EngineWriteReceipt(frames: [], failures: [.timedOut(record.app)], duration: behavior.duration) } let initial = record.writes.compactMap { write -> WindowFrame? in guard write.capturesInitialFrame, let frame = frames[write.window] else { return nil } return WindowFrame(window: write.window, frame: frame) } let observed = record.writes.map { write in var frame = behavior.refusesFrames ? frames[write.window] ?? write.frame : write.frame if let minimum = behavior.minimumSize { frame.size = Size( width: max(frame.size.width, minimum.width), height: max(frame.size.height, minimum.height)) } if let maximum = behavior.maximumSize { frame.size = Size( width: min(frame.size.width, maximum.width), height: min(frame.size.height, maximum.height)) } if let multiple = behavior.widthMultiple { frame.size.width = (frame.size.width / multiple).rounded(behavior.roundsWidthUp ? .up : .down) * multiple } if behavior.offsetWrites > 0 { frame.origin.xCoordinate += behavior.positionOffset.xCoordinate frame.origin.yCoordinate += behavior.positionOffset.yCoordinate behavior.offsetWrites -= 1 } frames[write.window] = frame if emitsEngineEchoes { emit(.frameChanged(write.window, frame: frame, resized: true, origin: .engine(write.transaction))) } return WindowFrame(window: write.window, frame: frame) } behaviors[record.app] = behavior return EngineWriteReceipt(frames: observed, duration: behavior.duration, initialFrames: initial) }}
@MainActorfinal class FakeEngineDisplayLink: EngineDisplayLink { var frameRate: Double = 120 private var tick: (@MainActor (Double) -> Void)? private var retainedTick: (@MainActor (Double) -> Void)? private(set) var isRunning = false private(set) var startCount = 0 private(set) var stopCount = 0
func start(tick: @escaping @MainActor (Double) -> Void) { self.tick = tick retainedTick = tick isRunning = true startCount += 1 }
func stop() { isRunning = false tick = nil stopCount += 1 }
func fire(at timestamp: Double) { tick?(timestamp) } func fireLate(at timestamp: Double) { retainedTick?(timestamp) }}
@MainActorfinal class FakeEngineLinks { private(set) var links: [DisplayID: FakeEngineDisplayLink] = [:] var creationFailure = false var runningCount: Int { links.values.filter(\.isRunning).count }
func make(_ display: DisplayID) throws -> any EngineDisplayLink { if creationFailure { throw HarnessError.startup } let link = FakeEngineDisplayLink() links[display] = link return link }
func tickAll(at timestamp: Double) { for display in links.keys.sorted() { links[display]?.fire(at: timestamp) } }}
@MainActorfinal class FakeEngineAnnouncer: EngineAnnouncer { private(set) var announcements: [Announcement] = [] func announce(_ announcement: Announcement) { announcements.append(announcement) }}
@MainActorfinal class FakeEngineLog: EngineLogSink { private(set) var diagnostics: [EngineDiagnostic] = [] var platformFailures: [EnginePlatformFailure] { diagnostics.compactMap { if case .platform(let failure) = $0 { failure } else { nil } } } var reports: [Report] { diagnostics.compactMap { if case .core(let report) = $0 { report } else { nil } } } var motionErrors: [MotionError] { diagnostics.compactMap { if case .motion(let error) = $0 { error } else { nil } } } func record(_ diagnostic: EngineDiagnostic) { diagnostics.append(diagnostic) }}
@MainActorfinal class FakeEngineTrace: EngineTraceSink { struct Entry: Equatable { let stage: EngineTraceStage let transaction: UInt64 let begins: Bool } private(set) var entries: [Entry] = [] func begin(_ stage: EngineTraceStage, transaction: UInt64) { entries.append(Entry(stage: stage, transaction: transaction, begins: true)) } func end(_ stage: EngineTraceStage, transaction: UInt64) { entries.append(Entry(stage: stage, transaction: transaction, begins: false)) }
func balance(for stage: EngineTraceStage) -> Int { entries.filter { $0.stage == stage }.reduce(0) { $0 + ($1.begins ? 1 : -1) } }}
@MainActorfinal class FakeEngineConfigurationSource: EngineConfigurationSource { var initial: ParcelConfiguration var startError: HarnessError? var deferStart = false private var changed: (@MainActor (ConfigSnapshot) -> Void)? private var retainedChanges: [@MainActor (ConfigSnapshot) -> Void] = [] private var startContinuation: CheckedContinuation<ParcelConfiguration, any Error>? private(set) var startCount = 0 private(set) var stopCount = 0 var isSubscribed: Bool { changed != nil } var isAwaitingStart: Bool { startContinuation != nil }
init(initial: ParcelConfiguration = engineConfiguration()) { self.initial = initial }
func start(changed: @escaping @MainActor (ConfigSnapshot) -> Void) async throws -> ParcelConfiguration { startCount += 1 self.changed = changed retainedChanges.append(changed) if let startError { throw startError } if deferStart { return try await withCheckedThrowingContinuation { startContinuation = $0 } } return initial }
func stop() async { stopCount += 1 changed = nil }
func emit(_ snapshot: ConfigSnapshot) { changed?(snapshot) } func emitFromStart(_ index: Int, snapshot: ConfigSnapshot) { retainedChanges[index](snapshot) }
func completeStart() throws { guard let continuation = startContinuation else { throw HarnessError.missingConfigurationStart } startContinuation = nil continuation.resume(returning: initial) }}
@MainActorfinal class EngineHarness { let clock = ManualEngineClock() let scheduler: ManualEngineScheduler let world: FakeEngineWorld let links = FakeEngineLinks() let announcer = FakeEngineAnnouncer() let log = FakeEngineLog() let trace = FakeEngineTrace() let engine: ParcelEngine
init( configuration: ParcelConfiguration = engineConfiguration(), initialState: State = engineInitialState(), configSource: (any EngineConfigurationSource)? = nil, recorder: (any EngineEventRecorder)? = nil, minimumSizeStore: MinimumSizeStore? = nil, spaceWorld: (any EngineSpaceWorld)? = nil, workspaceStateStore: WorkspaceStateStore? = nil, ruleSpaceMoveStore: RuleSpaceMoveStore? = nil, startupWindowIDs: (@Sendable () async throws -> Set<WindowID>)? = nil ) throws { scheduler = ManualEngineScheduler(clock: clock) world = FakeEngineWorld(clock: clock) let links = links engine = try ParcelEngine( world: world, clock: clock, scheduler: scheduler, displayLink: { try links.make($0) }, announcer: announcer, log: log, configuration: configuration, initialState: initialState, configSource: configSource, trace: trace, reduceMotionSource: nil, recorder: recorder, minimumSizeStore: minimumSizeStore, spaceWorld: spaceWorld, workspaceStateStore: workspaceStateStore, ruleSpaceMoveStore: ruleSpaceMoveStore, startupWindowIDs: startupWindowIDs ) }
func start() async throws { try await engine.start() try scheduler.runReady() }
func add(_ ids: [UInt32], app: AppID = engineApp, workspace: WorkspaceKey = engineWorkspace) throws { for id in ids { world.appear(engineWindow(id, app: app), workspace: workspace) } try scheduler.runReady() }
func finishMotion(after interval: Double = 2) throws { clock.now += interval links.tickAll(at: clock.now) try scheduler.runReady() }}