Capture is now a decision, not a hidden setting. The popover shows a four-way scope control with the target named under it (800 x 600 on Display 1, the frontmost window, the front browser window, the whole display), and the window header carries the same choice beside the verbs. Picking Window or Browser hides Redline, dims the screen, names the app under the pointer and highlights its window; a click captures exactly that window, Escape cancels, and the desktop highlights the whole screen. New Session is one click: the current captures stay in their own folder, a fresh session opens, and the area picker comes straight up with the saved area pre-selected — Return keeps it, a drag replaces it. Settings is consolidated into one door (the popover gear, plus Cmd-,): what to capture, saved area, shortcut, ask-on-new-session, sending, session age limit, and a new Updates group with automatic install (on by default; installs only when nothing is unsent). The footer filler and the extra-actions menu are gone.
566 lines
25 KiB
Swift
566 lines
25 KiB
Swift
import AppKit
|
||
import CoreGraphics
|
||
import Darwin
|
||
import Foundation
|
||
import ImageIO
|
||
import PDFKit
|
||
import SwiftUI
|
||
import ShotdeckCore
|
||
|
||
/// Headless offscreen renderer for `MenuBarView` / `SettingsView`.
|
||
/// Driven by `SHOTDECK_SNAPSHOT_DIR`; never touches the real Application Support spool.
|
||
enum PanelSnapshot {
|
||
private static let panelWidth: CGFloat = 340
|
||
|
||
/// Called from `main.swift` before `ShotdeckApp.main()`. Returns immediately when the
|
||
/// env var is unset; otherwise writes the six panel PNGs, prints each path, and `exit`s.
|
||
@MainActor
|
||
static func runIfRequested() {
|
||
guard let raw = ProcessInfo.processInfo.environment["SHOTDECK_SNAPSHOT_DIR"],
|
||
!raw.isEmpty
|
||
else { return }
|
||
|
||
let app = NSApplication.shared
|
||
app.setActivationPolicy(.prohibited)
|
||
|
||
Task { @MainActor in
|
||
do {
|
||
try await captureAll(to: URL(fileURLWithPath: raw, isDirectory: true))
|
||
exit(0)
|
||
} catch {
|
||
fputs("PanelSnapshot failed: \(error)\n", stderr)
|
||
exit(1)
|
||
}
|
||
}
|
||
|
||
app.run()
|
||
exit(0)
|
||
}
|
||
|
||
@MainActor
|
||
private static func captureAll(to directory: URL) async throws {
|
||
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
|
||
|
||
let (model, root) = try makeIsolatedModel()
|
||
defer { try? FileManager.default.removeItem(at: root) }
|
||
|
||
let region = sampleRegion()
|
||
|
||
// Two real past sessions through the REAL store paths (one sent with a PDF in
|
||
// the outbox, one closed without ever sending) so panel-06b has the exact two
|
||
// states the Past submissions window must distinguish.
|
||
try await seedPastSessions(to: model)
|
||
|
||
// 01 — Screen Recording missing (no public mutator; snapshot-only seam).
|
||
model.snapshotSetScreenRecordingGranted(false)
|
||
model.replaceRegion(nil)
|
||
try renderMenuBar(model: model, to: directory, name: "01-no-permission")
|
||
|
||
// 02 — granted, no region picked.
|
||
model.snapshotSetScreenRecordingGranted(true)
|
||
model.replaceRegion(nil)
|
||
try renderMenuBar(model: model, to: directory, name: "02-no-region")
|
||
|
||
// 03 — region set, empty session.
|
||
model.replaceRegion(region)
|
||
try renderMenuBar(model: model, to: directory, name: "03-empty-session")
|
||
|
||
// 04 — three real PNGs in the temp spool so SessionStrip thumbnails decode.
|
||
try await addSampleCaptures(to: model)
|
||
try renderMenuBar(model: model, to: directory, name: "04-captures-present")
|
||
|
||
// 05 — two inspected PDFs in the temp ledger, one marked / one not.
|
||
try await seedReturns(model: model)
|
||
try renderMenuBar(model: model, to: directory, name: "05-returns-present")
|
||
|
||
// 06 — SettingsView against the same isolated model.
|
||
try render(
|
||
SettingsView().environment(model),
|
||
to: directory.appendingPathComponent("panel-06-settings.png"),
|
||
width: 460,
|
||
height: 820
|
||
)
|
||
|
||
// 06b — the sessions window: real sidebar, pages grid and inspector.
|
||
model.setPastSessions(try await model.spool.archivedSessions())
|
||
try render(
|
||
SessionsWindowView().environment(model),
|
||
to: directory.appendingPathComponent("panel-06b-sessions-window.png"),
|
||
width: 1100,
|
||
height: 700
|
||
)
|
||
|
||
// 15 — the window with a kept past session selected (read-only inspector).
|
||
if let kept = model.pastSessions.first {
|
||
model.selectSession(kept.id)
|
||
try render(
|
||
SessionsWindowView().environment(model),
|
||
to: directory.appendingPathComponent("panel-15-past-session.png"),
|
||
width: 1100,
|
||
height: 700
|
||
)
|
||
model.selectSession(model.session.id)
|
||
}
|
||
|
||
// A real PDF built by the production composer, so the reference footer and the
|
||
// document info can be inspected (and opened) rather than assumed.
|
||
try writeSamplePDF(to: directory.appendingPathComponent("sample-review.pdf"), model: model)
|
||
|
||
// 07/08/09 — OneDrive-mode Settings + menu bar, on a SEPARATE isolated model so
|
||
// this transport switch never bleeds into the AirDrop-mode panels above.
|
||
try await captureOneDrivePanels(to: directory)
|
||
}
|
||
|
||
/// Three real PNGs appended to the given model's temp spool so SessionStrip
|
||
/// thumbnails decode. Shared by panel 04 (AirDrop) and panel 09 (OneDrive).
|
||
@MainActor
|
||
private static func addSampleCaptures(to model: AppModel) async throws {
|
||
let swatches: [(CGFloat, CGFloat, CGFloat)] = [
|
||
(0.85, 0.22, 0.18),
|
||
(0.18, 0.62, 0.32),
|
||
(0.16, 0.38, 0.82),
|
||
]
|
||
for (red, green, blue) in swatches {
|
||
let png = try makePNGData(width: 192, height: 108, red: red, green: green, blue: blue)
|
||
_ = try await model.spool.append(
|
||
pngData: png,
|
||
pixelWidth: 192,
|
||
pixelHeight: 108,
|
||
scale: 2.0,
|
||
capturedAt: Date()
|
||
)
|
||
}
|
||
model.replaceSession(try await model.spool.currentSession())
|
||
}
|
||
|
||
/// Panels 07-09: OneDrive transport, on its own isolated model/temp root so
|
||
/// switching transport here never touches the AirDrop-mode model above, the real
|
||
/// home directory, or UserDefaults.standard. The "resolved" and "not found" states
|
||
/// are produced by calling the real OneDriveLocator functions against fake home
|
||
/// trees built under this snapshot's own temp root — never a hand-typed path.
|
||
@MainActor
|
||
private static func captureOneDrivePanels(to directory: URL) async throws {
|
||
let (model, root) = try makeIsolatedModel()
|
||
defer { try? FileManager.default.removeItem(at: root) }
|
||
model.setTransport(.oneDrive)
|
||
|
||
// 07 — a resolved OneDrive folder, shaped like the real default
|
||
// (…/Library/CloudStorage/OneDrive-MMDGROUP/Redline): a fake home tree with a
|
||
// real OneDrive-MMDGROUP directory under it, resolved via the same pure
|
||
// OneDriveLocator function production code uses — never a hand-typed path.
|
||
let fakeHomeWithOneDrive = root.appendingPathComponent("fake-home-with-onedrive", isDirectory: true)
|
||
let syncRoot = fakeHomeWithOneDrive
|
||
.appendingPathComponent("Library/CloudStorage/OneDrive-MMDGROUP", isDirectory: true)
|
||
try FileManager.default.createDirectory(at: syncRoot, withIntermediateDirectories: true)
|
||
guard let resolvedFolder = OneDriveLocator.defaultRedlineFolder(
|
||
home: fakeHomeWithOneDrive, fileManager: .default
|
||
) else {
|
||
throw SnapshotError.oneDriveFixtureFailed("fake OneDrive-MMDGROUP root did not resolve")
|
||
}
|
||
model.setResolvedOneDriveFolder(resolvedFolder)
|
||
try render(
|
||
SettingsView().environment(model),
|
||
to: directory.appendingPathComponent("panel-07-settings-onedrive.png"),
|
||
width: 460,
|
||
height: 820
|
||
)
|
||
|
||
// 08 — no OneDrive folder found: a fake home with NO Library/CloudStorage at
|
||
// all, and a throwaway UserDefaults suite (never .standard, never touched
|
||
// before) so the stored-override check also legitimately finds nothing.
|
||
let fakeHomeWithoutOneDrive = root.appendingPathComponent("fake-home-without-onedrive", isDirectory: true)
|
||
try FileManager.default.createDirectory(at: fakeHomeWithoutOneDrive, withIntermediateDirectories: true)
|
||
let isolatedDefaults = try makeIsolatedDefaultsSuite()
|
||
defer { isolatedDefaults.defaults.removePersistentDomain(forName: isolatedDefaults.suiteName) }
|
||
let missingFolder = OneDriveLocator.resolveOneDriveFolder(
|
||
defaults: isolatedDefaults.defaults, home: fakeHomeWithoutOneDrive, fileManager: .default
|
||
)
|
||
guard missingFolder == nil else {
|
||
throw SnapshotError.oneDriveFixtureFailed("fake home without OneDrive unexpectedly resolved")
|
||
}
|
||
model.setResolvedOneDriveFolder(nil)
|
||
try render(
|
||
SettingsView().environment(model),
|
||
to: directory.appendingPathComponent("panel-08-settings-onedrive-missing.png"),
|
||
width: 460,
|
||
height: 820
|
||
)
|
||
|
||
// 09 — menu bar panel, 3 captures present, OneDrive mode ("Send to OneDrive").
|
||
model.snapshotSetScreenRecordingGranted(true)
|
||
model.replaceRegion(sampleRegion())
|
||
try await addSampleCaptures(to: model)
|
||
try renderMenuBar(model: model, to: directory, name: "09-captures-present-onedrive")
|
||
|
||
// 10 — update idle: 3 captures, no update available, footer "Redline <ver>", row "Check for updates".
|
||
let (updateModel, updateRoot) = try makeIsolatedModel()
|
||
defer { try? FileManager.default.removeItem(at: updateRoot) }
|
||
updateModel.snapshotSetScreenRecordingGranted(true)
|
||
updateModel.replaceRegion(sampleRegion())
|
||
try await addSampleCaptures(to: updateModel)
|
||
// No update set, updateChecker in idle state, no previous version
|
||
updateModel.snapshotSetPreviousVersion(nil)
|
||
try renderMenuBar(model: updateModel, to: directory, name: "10-update-idle")
|
||
|
||
// 11 — update checking: same as 10 but isCheckingForUpdates = true.
|
||
updateModel.snapshotSetIsCheckingForUpdates(true)
|
||
try renderMenuBar(model: updateModel, to: directory, name: "11-update-checking")
|
||
updateModel.snapshotSetIsCheckingForUpdates(false)
|
||
|
||
// 12 — update up-to-date: footer status line reads "Redline <ver> is up to date, checked 10:42 Dubai".
|
||
let upToDateMessage = "Redline \(updateModel.appVersion) is up to date, checked 10:42 Dubai"
|
||
updateModel.snapshotSetUpdateStatusMessage(upToDateMessage)
|
||
try renderMenuBar(model: updateModel, to: directory, name: "12-update-uptodate")
|
||
|
||
// 13 — update staged: row "Update to 9.9.9" present, footer status "Update to 9.9.9 is ready".
|
||
updateModel.snapshotSetUpdateAvailable(version: "9.9.9", notes: "Test release")
|
||
updateModel.snapshotSetUpdateStatusMessage("Update to 9.9.9 is ready")
|
||
try renderMenuBar(model: updateModel, to: directory, name: "13-update-staged")
|
||
|
||
// 14 — update revert: row "Revert to 0.2.0" present.
|
||
updateModel.snapshotSetUpdateAvailable(version: nil, notes: nil) // Clear the staged update
|
||
updateModel.snapshotSetUpdateStatusMessage(nil)
|
||
updateModel.snapshotSetPreviousVersion("0.2.0")
|
||
try renderMenuBar(model: updateModel, to: directory, name: "14-update-revert")
|
||
}
|
||
|
||
@MainActor
|
||
private static func seedPastSessions(to model: AppModel) async throws {
|
||
_ = try await model.spool.append(
|
||
pngData: try makePNGData(width: 192, height: 108, red: 0.55, green: 0.35, blue: 0.85),
|
||
pixelWidth: 192, pixelHeight: 108, scale: 2.0, capturedAt: Date())
|
||
_ = try await model.spool.append(
|
||
pngData: try makePNGData(width: 192, height: 108, red: 0.25, green: 0.7, blue: 0.6),
|
||
pixelWidth: 192, pixelHeight: 108, scale: 2.0, capturedAt: Date())
|
||
let sentSession = try await model.spool.setContext(
|
||
ReviewContext(
|
||
lane: "DEV03", deployedVersion: "v1.4.2 (41)", commit: "a1b2c3d4",
|
||
reviewer: "Ben Hippler", note: "checkout flow"))
|
||
let sentName = PDFFileName.make(
|
||
builtAt: Date(), lane: sentSession.context.lane, sessionID: sentSession.id)
|
||
_ = try await model.spool.archiveCurrent(pdfFileName: sentName)
|
||
// The real send writes the PDF to the outbox; the fixture does the same so the
|
||
// row's PDF action is genuinely live in the snapshot.
|
||
try Data("%PDF-1.4\n% snapshot fixture\n".utf8).write(
|
||
to: model.paths.outbox.appendingPathComponent(sentName))
|
||
|
||
_ = try await model.spool.append(
|
||
pngData: try makePNGData(width: 160, height: 90, red: 0.9, green: 0.55, blue: 0.2),
|
||
pixelWidth: 160, pixelHeight: 90, scale: 2.0, capturedAt: Date())
|
||
_ = try await model.spool.setContext(
|
||
ReviewContext(
|
||
lane: "OMS test lane", deployedVersion: "v2.0.0-rc3", commit: "9f3e2d1",
|
||
reviewer: "Ben Hippler"))
|
||
_ = try await model.spool.closeCurrentSession()
|
||
|
||
// The live session shown in panels 03/04/05/15 carries details too.
|
||
_ = try await model.spool.setContext(
|
||
ReviewContext(
|
||
lane: "DEV03", deployedVersion: "v1.4.2 (41)", commit: "a1b2c3d4",
|
||
reviewer: "Ben Hippler", note: "dashboard review"))
|
||
model.replaceSession(try await model.spool.currentSession())
|
||
// Both seeded sessions are really on disk by now; load them into the model so
|
||
// the panel's recent list is live rather than empty.
|
||
model.setPastSessions(try await model.spool.archivedSessions())
|
||
}
|
||
|
||
/// A real PDF from the production composer: one page per capture, header reference
|
||
/// line and the review footer. Written next to the panels so it can be opened.
|
||
@MainActor
|
||
private static func writeSamplePDF(to url: URL, model: AppModel) throws {
|
||
let session = model.session
|
||
guard !session.isEmpty else { return }
|
||
let sourceDir = model.paths.sessionDirectory(session.id)
|
||
_ = try PDFComposer().compose(
|
||
session: session,
|
||
imageURL: { capture in sourceDir.appendingPathComponent(capture.fileName) },
|
||
title: "Redline – \(session.context.lane) – \(DubaiTime.stamp(session.createdAt))",
|
||
to: url,
|
||
toolVersion: model.appVersion
|
||
)
|
||
}
|
||
|
||
@MainActor
|
||
private static func renderMenuBar(model: AppModel, to directory: URL, name: String) throws {
|
||
try render(
|
||
MenuBarView().environment(model),
|
||
to: directory.appendingPathComponent("panel-\(name).png")
|
||
)
|
||
}
|
||
|
||
@MainActor
|
||
private static func render(
|
||
_ view: some View,
|
||
to url: URL,
|
||
width: CGFloat = panelWidth,
|
||
height: CGFloat? = nil
|
||
) throws {
|
||
// A fixed-size render (a whole window) must fill its frame; a popover render
|
||
// sizes to its content. fixedSize on a split view collapses its columns.
|
||
let wrapped = Group {
|
||
if let height {
|
||
view.frame(width: width, height: height)
|
||
} else {
|
||
view
|
||
.frame(width: width, alignment: .topLeading)
|
||
.fixedSize(horizontal: false, vertical: true)
|
||
}
|
||
}
|
||
.frame(width: width, height: height, alignment: .topLeading)
|
||
.background(Color(nsColor: .windowBackgroundColor))
|
||
|
||
let hosting = NSHostingView(rootView: wrapped)
|
||
hosting.wantsLayer = true
|
||
hosting.appearance = NSAppearance(named: .aqua)
|
||
|
||
let window = NSWindow(
|
||
contentRect: NSRect(x: -10_000, y: -10_000, width: width, height: 200),
|
||
styleMask: [.borderless],
|
||
backing: .buffered,
|
||
defer: false
|
||
)
|
||
window.isReleasedWhenClosed = false
|
||
window.appearance = NSAppearance(named: .aqua)
|
||
window.backgroundColor = .windowBackgroundColor
|
||
window.isOpaque = true
|
||
window.alphaValue = 0
|
||
window.contentView = hosting
|
||
window.orderBack(nil)
|
||
|
||
hosting.layoutSubtreeIfNeeded()
|
||
var size = hosting.fittingSize
|
||
if let height {
|
||
size.height = height
|
||
} else {
|
||
if size.height < 1 {
|
||
size.height = hosting.intrinsicContentSize.height
|
||
}
|
||
if size.height < 1 { size.height = 240 }
|
||
}
|
||
size.width = width
|
||
size.height = ceil(size.height)
|
||
|
||
hosting.setFrameSize(size)
|
||
window.setContentSize(size)
|
||
hosting.layoutSubtreeIfNeeded()
|
||
// A split view (sidebar + inspector) needs a real display cycle before its
|
||
// columns and list rows exist; a single layout pass renders blank columns.
|
||
window.displayIfNeeded()
|
||
RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.35))
|
||
hosting.layoutSubtreeIfNeeded()
|
||
window.displayIfNeeded()
|
||
|
||
let bounds = hosting.bounds
|
||
guard let rep = hosting.bitmapImageRepForCachingDisplay(in: bounds) else {
|
||
throw SnapshotError.renderFailed(url.lastPathComponent)
|
||
}
|
||
hosting.cacheDisplay(in: bounds, to: rep)
|
||
guard let png = rep.representation(using: .png, properties: [:]) else {
|
||
throw SnapshotError.encodeFailed(url.lastPathComponent)
|
||
}
|
||
try png.write(to: url)
|
||
print(url.path)
|
||
fflush(stdout)
|
||
|
||
window.contentView = nil
|
||
window.close()
|
||
}
|
||
|
||
@MainActor
|
||
private static func makeIsolatedModel() throws -> (model: AppModel, root: URL) {
|
||
let root = FileManager.default.temporaryDirectory
|
||
.appendingPathComponent("shotdeck-panel-snapshot-\(UUID().uuidString)", isDirectory: true)
|
||
let paths = try AppSupportPaths(
|
||
root: root,
|
||
outbox: root.appendingPathComponent("outbox", isDirectory: true),
|
||
watchFolder: root.appendingPathComponent("watch", isDirectory: true)
|
||
)
|
||
let ledger = try ReturnLedger(paths: paths)
|
||
// Isolated defaults: rendering a panel must never read or write the real
|
||
// age-limit preference.
|
||
let suite = try makeIsolatedDefaultsSuite()
|
||
let model = AppModel(
|
||
paths: paths,
|
||
spool: try SpoolStore(paths: paths),
|
||
composer: PDFComposer(),
|
||
capturer: ScreenCapturer(),
|
||
hotkeys: HotkeyCenter(),
|
||
picker: RegionPickerController(),
|
||
ledger: ledger,
|
||
watcher: ReturnWatcher(paths: paths, ledger: ledger),
|
||
retentionDefaults: suite.defaults
|
||
)
|
||
model.setFolderURLs(outbox: paths.outbox, watch: paths.watchFolder)
|
||
return (model, root)
|
||
}
|
||
|
||
/// A throwaway UserDefaults suite — never `.standard` — for the panel-08 fixture,
|
||
/// the same isolation pattern ShotdeckCoreTests uses for TransportSettings/
|
||
/// OneDriveLocator tests.
|
||
private struct IsolatedDefaultsSuite {
|
||
let suiteName: String
|
||
let defaults: UserDefaults
|
||
}
|
||
|
||
private static func makeIsolatedDefaultsSuite() throws -> IsolatedDefaultsSuite {
|
||
let suiteName = "shotdeck-panel-snapshot-\(UUID().uuidString)"
|
||
guard let defaults = UserDefaults(suiteName: suiteName) else {
|
||
throw SnapshotError.oneDriveFixtureFailed("could not create isolated UserDefaults suite")
|
||
}
|
||
defaults.removePersistentDomain(forName: suiteName)
|
||
return IsolatedDefaultsSuite(suiteName: suiteName, defaults: defaults)
|
||
}
|
||
|
||
@MainActor
|
||
private static func seedReturns(model: AppModel) async throws {
|
||
let watch = model.paths.watchFolder
|
||
let unmarkedURL = watch.appendingPathComponent("Shotdeck-20260901-120000.pdf")
|
||
let markedURL = watch.appendingPathComponent("Shotdeck-20260901-120100.pdf")
|
||
try writeShotdeckPDF(to: unmarkedURL, marked: false)
|
||
try writeShotdeckPDF(to: markedURL, marked: true)
|
||
|
||
let unmarked = try AnnotationInspector.inspect(fileURL: unmarkedURL)
|
||
let marked = try AnnotationInspector.inspect(fileURL: markedURL)
|
||
try await model.ledger.record(unmarked)
|
||
try await model.ledger.record(marked)
|
||
model.setReturns(
|
||
all: try await model.ledger.all(),
|
||
commented: try await model.ledger.commented()
|
||
)
|
||
}
|
||
|
||
private static func sampleRegion() -> CaptureRegion {
|
||
CaptureRegion(
|
||
displayID: CGMainDisplayID(),
|
||
rect: CGRect(x: 120, y: 80, width: 800, height: 600),
|
||
capturedScale: 2.0
|
||
)
|
||
}
|
||
|
||
private static func makePNGData(
|
||
width: Int,
|
||
height: Int,
|
||
red: CGFloat,
|
||
green: CGFloat,
|
||
blue: CGFloat
|
||
) throws -> Data {
|
||
let colorSpace = CGColorSpaceCreateDeviceRGB()
|
||
guard let context = CGContext(
|
||
data: nil,
|
||
width: width,
|
||
height: height,
|
||
bitsPerComponent: 8,
|
||
bytesPerRow: width * 4,
|
||
space: colorSpace,
|
||
bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
|
||
) else {
|
||
throw SnapshotError.pngGenerationFailed
|
||
}
|
||
context.setFillColor(red: red, green: green, blue: blue, alpha: 1)
|
||
context.fill(CGRect(x: 0, y: 0, width: width, height: height))
|
||
guard let image = context.makeImage() else {
|
||
throw SnapshotError.pngGenerationFailed
|
||
}
|
||
let buffer = NSMutableData()
|
||
guard let destination = CGImageDestinationCreateWithData(
|
||
buffer,
|
||
"public.png" as CFString,
|
||
1,
|
||
nil
|
||
) else {
|
||
throw SnapshotError.pngGenerationFailed
|
||
}
|
||
CGImageDestinationAddImage(destination, image, nil)
|
||
guard CGImageDestinationFinalize(destination) else {
|
||
throw SnapshotError.pngGenerationFailed
|
||
}
|
||
return buffer as Data
|
||
}
|
||
|
||
private static func writeShotdeckPDF(to url: URL, marked: Bool) throws {
|
||
let document = PDFDocument()
|
||
let page = PDFPage()
|
||
page.setBounds(CGRect(x: 0, y: 0, width: 612, height: 792), for: .mediaBox)
|
||
document.insert(page, at: 0)
|
||
document.documentAttributes = [
|
||
PDFDocumentAttribute.creatorAttribute: "Shotdeck",
|
||
PDFDocumentAttribute.subjectAttribute: UUID().uuidString,
|
||
]
|
||
if marked {
|
||
let annotation = PDFAnnotation(
|
||
bounds: CGRect(x: 72, y: 400, width: 220, height: 36),
|
||
forType: .highlight,
|
||
withProperties: nil
|
||
)
|
||
page.addAnnotation(annotation)
|
||
}
|
||
guard document.write(to: url) else {
|
||
throw SnapshotError.pdfWriteFailed(url.lastPathComponent)
|
||
}
|
||
}
|
||
}
|
||
|
||
extension AppModel {
|
||
/// `screenRecordingGranted` is `public private(set)` with no seam mutator.
|
||
/// Snapshot-only: the KeyPath setter exists at runtime; compile-time access is file-private.
|
||
func snapshotSetScreenRecordingGranted(_ granted: Bool) {
|
||
// private(set) types this as KeyPath; the setter still exists on the @Observable storage.
|
||
let writable: ReferenceWritableKeyPath<AppModel, Bool> = unsafeBitCast(
|
||
\AppModel.screenRecordingGranted, to: ReferenceWritableKeyPath<AppModel, Bool>.self
|
||
)
|
||
self[keyPath: writable] = granted
|
||
}
|
||
|
||
/// Snapshot-only: set isCheckingForUpdates without triggering a real check.
|
||
func snapshotSetIsCheckingForUpdates(_ checking: Bool) {
|
||
let writable: ReferenceWritableKeyPath<AppModel, Bool> = unsafeBitCast(
|
||
\AppModel.isCheckingForUpdates, to: ReferenceWritableKeyPath<AppModel, Bool>.self
|
||
)
|
||
self[keyPath: writable] = checking
|
||
}
|
||
|
||
/// Snapshot-only: set updateStatusMessage for panel display.
|
||
func snapshotSetUpdateStatusMessage(_ message: String?) {
|
||
setUpdateStatus(message)
|
||
}
|
||
|
||
/// Snapshot-only: set updateAvailable without triggering a real download.
|
||
func snapshotSetUpdateAvailable(version: String?, notes: String?) {
|
||
if let version = version, let notes = notes {
|
||
let writable: ReferenceWritableKeyPath<AppModel, (version: String, notes: String)?> = unsafeBitCast(
|
||
\AppModel.updateAvailable, to: ReferenceWritableKeyPath<AppModel, (version: String, notes: String)?>.self
|
||
)
|
||
self[keyPath: writable] = (version: version, notes: notes)
|
||
} else {
|
||
let writable: ReferenceWritableKeyPath<AppModel, (version: String, notes: String)?> = unsafeBitCast(
|
||
\AppModel.updateAvailable, to: ReferenceWritableKeyPath<AppModel, (version: String, notes: String)?>.self
|
||
)
|
||
self[keyPath: writable] = nil
|
||
}
|
||
}
|
||
|
||
/// Snapshot-only: set a fake previousVersion for the revert panel.
|
||
func snapshotSetPreviousVersion(_ version: String?) {
|
||
updateChecker.snapshotPreviousVersionOverride = version
|
||
updateChecker.snapshotUsesPreviousVersionOverride = true
|
||
}
|
||
}
|
||
|
||
private enum SnapshotError: Error, CustomStringConvertible {
|
||
case renderFailed(String)
|
||
case encodeFailed(String)
|
||
case pngGenerationFailed
|
||
case pdfWriteFailed(String)
|
||
case oneDriveFixtureFailed(String)
|
||
|
||
var description: String {
|
||
switch self {
|
||
case .renderFailed(let name): return "bitmapImageRepForCachingDisplay failed for \(name)"
|
||
case .encodeFailed(let name): return "PNG encode failed for \(name)"
|
||
case .pngGenerationFailed: return "CoreGraphics PNG generation failed"
|
||
case .pdfWriteFailed(let name): return "could not write \(name)"
|
||
case .oneDriveFixtureFailed(let detail): return "OneDrive snapshot fixture failed: \(detail)"
|
||
}
|
||
}
|
||
}
|