The menu-bar popover was being used as a session manager: status, five text fields, thumbnails, three buttons, a history list and eight more flat rows in 320 pt. The redesign splits the product by job, from a UX pass whose mockups are kept under design/ux-rework/. - Popover: only the current session. Review details as one line plus a pencil that opens the window with the Lane field focused, at most three thumbnails, a Capture and a Send row, a New Session and Open Redline row, one status line when something happened, and a footer with the send channel, the retention policy and a ... menu for Settings / updates / quit. - Window: sidebar of sessions grouped Today / Yesterday / This week / by month with a Current tag and each session's state, the selected session's pages as cards (select, Delete or Remove Page, sent sessions read-only), and an inspector with editable review details, the PDF facts (file name, pages, channel, status) and the session facts (started, id, files). Past sessions show their details read-only. - Settings: three labelled groups (Capture, Sending, Sessions) replacing the headings-plus-grid layout. - Sessions list/search/grouping/state live on the model, so the window and the popover read the same truth (came-back-marked state comes from the return ledger). - Verification: 159 tests, the headless panel self-test, and an end-to-end run against the active app (scripts/run-e2e-ui.sh) which opens the real window, types into the Lane field with key events and clicks New Session, reporting what the launch mode could and could not deliver.
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: 560
|
||
)
|
||
|
||
// 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: 560
|
||
)
|
||
|
||
// 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: 560
|
||
)
|
||
|
||
// 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)"
|
||
}
|
||
}
|
||
}
|