Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172public struct MotionWindowID: RawRepresentable, Sendable, Hashable, Comparable { public let rawValue: UInt64 public init(rawValue: UInt64) { self.rawValue = rawValue } public static func < (lhs: Self, rhs: Self) -> Bool { lhs.rawValue < rhs.rawValue }}
public struct MotionAppID: RawRepresentable, Sendable, Hashable, Comparable { public let rawValue: Int32 public init(rawValue: Int32) { self.rawValue = rawValue } public static func < (lhs: Self, rhs: Self) -> Bool { lhs.rawValue < rhs.rawValue }}
public struct MotionSize: Sendable, Equatable { public var width: Double public var height: Double
public init(width: Double, height: Double) { self.width = width self.height = height }
public static let zero = Self(width: 0, height: 0) var isValid: Bool { width.isFinite && height.isFinite && width >= 0 && height >= 0 }}
public struct MotionRect: Sendable, Equatable { public var originX: Double public var originY: Double public var width: Double public var height: Double
public init(originX: Double, originY: Double, width: Double, height: Double) { self.originX = originX self.originY = originY self.width = width self.height = height }
public var maxX: Double { originX + width } public var maxY: Double { originY + height } public var size: MotionSize { MotionSize(width: width, height: height) } var isValid: Bool { originX.isFinite && originY.isFinite && size.isValid && maxX.isFinite && maxY.isFinite }}
public struct MotionVelocity: Sendable, Equatable { public var horizontal: Double public var vertical: Double public var width: Double public var height: Double
public init(horizontal: Double = 0, vertical: Double = 0, width: Double = 0, height: Double = 0) { self.horizontal = horizontal self.vertical = vertical self.width = width self.height = height }
public static let zero = Self() var isValid: Bool { horizontal.isFinite && vertical.isFinite && width.isFinite && height.isFinite }}
public enum MotionError: Error, Sendable, Equatable { case invalidGeometry case minimumSizeExceedsScreen case invalidTimestamp case timestampWentBackwards case duplicateWindow(MotionWindowID) case invalidOpacity case invalidVelocity case unknownBatch}
struct FrameBounds: Sendable { let screen: MotionRect let minimumSize: MotionSize
init(screen: MotionRect, minimumSize: MotionSize) throws { guard screen.isValid && minimumSize.isValid else { throw MotionError.invalidGeometry } let left = screen.originX.rounded(.up) let bottom = screen.originY.rounded(.up) let right = screen.maxX.rounded(.down) let top = screen.maxY.rounded(.down) guard right >= left && top >= bottom else { throw MotionError.invalidGeometry } guard minimumSize.width.rounded(.up) <= right - left, minimumSize.height.rounded(.up) <= top - bottom else { throw MotionError.minimumSizeExceedsScreen } self.screen = MotionRect(originX: left, originY: bottom, width: right - left, height: top - bottom) self.minimumSize = MotionSize( width: minimumSize.width.rounded(.up), height: minimumSize.height.rounded(.up) ) }
func constrained(_ rect: MotionRect, rounded: Bool) -> MotionRect { let width = min(screen.width, max(minimumSize.width, rounded ? rect.width.rounded() : rect.width)) let height = min(screen.height, max(minimumSize.height, rounded ? rect.height.rounded() : rect.height)) return MotionRect( originX: min(screen.maxX - width, max(screen.originX, rounded ? rect.originX.rounded() : rect.originX)), originY: min(screen.maxY - height, max(screen.originY, rounded ? rect.originY.rounded() : rect.originY)), width: width, height: height ) }}
public struct AppWriteMetrics: Sendable, Equatable { public static let schemaVersion = 2 public private(set) var averageWriteDuration: Double? public private(set) var lastTimeout: Double? public let launchedAt: Double? public private(set) var sampleCount: Int = 0 private var writeDurations: [Double] = [] private var nextDuration = 0
public var retainedSampleCount: Int { writeDurations.count } public var p50WriteDuration: Double? { percentile(0.5) } public var p95WriteDuration: Double? { percentile(0.95) }
public init(launchedAt: Double? = nil) { precondition(launchedAt == nil || launchedAt?.isFinite == true) self.launchedAt = launchedAt }
public mutating func record(duration: Double, timedOut: Bool = false, at timestamp: Double) throws { guard duration.isFinite && duration >= 0 && timestamp.isFinite else { throw MotionError.invalidTimestamp } if let averageWriteDuration { self.averageWriteDuration = averageWriteDuration + 0.2 * (duration - averageWriteDuration) } else { averageWriteDuration = duration } sampleCount += 1 if writeDurations.count == 256 { writeDurations[nextDuration] = duration nextDuration = (nextDuration + 1) % 256 } else { writeDurations.append(duration) } if timedOut { lastTimeout = timestamp } }
private func percentile(_ fraction: Double) -> Double? { guard !writeDurations.isEmpty else { return nil } let rank = Int((Double(writeDurations.count) * fraction).rounded(.up)) return writeDurations.sorted()[rank - 1] }
public func isSlow(at timestamp: Double) -> Bool { precondition(timestamp.isFinite) if let averageWriteDuration, averageWriteDuration > 0.040 { return true } if let lastTimeout, timestamp - lastTimeout < 5 { return true } return false }
public func shouldSnap(at timestamp: Double) -> Bool { if isSlow(at: timestamp) { return true } if let launchedAt, timestamp - launchedAt < 1.5 { return true } return false }
public func frameRate(fullRate: Double = 120, windowsInMotion: Int = 1) -> Double { precondition(fullRate.isFinite && fullRate > 0 && windowsInMotion > 0) guard let averageWriteDuration, averageWriteDuration > 0 else { return fullRate } return min(fullRate, max(30, 1 / (averageWriteDuration * Double(windowsInMotion)))) }
public func animationWindowBudget(minimumRate: Double = 45) -> Int? { precondition(minimumRate.isFinite && minimumRate > 0) guard let averageWriteDuration, averageWriteDuration > 0 else { return nil } let capacity = 1 / minimumRate / averageWriteDuration guard capacity < Double(Int.max) else { return nil } return max(1, Int(capacity)) }}