Sessions are now the unit of the product instead of an implicit capture run. - Nothing is deleted by default: the fixed 10-session cap is gone. An age limit (Never / 7 / 14 / 30 / 90 / 180 / 365 days) is chosen in Settings > Sessions and applied on launch, after archiving, and by "Clean up now". Sent PDFs are never touched. - Each session carries review details: lane, deployed version, commit, reviewer (pre-filled with the Mac user) and a free note. They persist in session.json and are inherited by the next session, so a review run is typed once. - PDF file names are Redline-<yyyyMMdd-HHmm>-<LANE>-<SHORTID>.pdf, and every page carries a two-line reference footer (tool, build time, session / lane, deployed build, commit, reviewer, note). The PDF document info carries the same values in Author and Keywords. - Verification: 159 tests, a headless panel self-test, and a LaunchServices-driven end-to-end run that types and clicks the real panel.
532 lines
24 KiB
Swift
532 lines
24 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")
|
||
)
|
||
|
||
// 06b — Past submissions window against the same isolated model: the two
|
||
// seeded past sessions plus the live session's three captures from panel 04.
|
||
model.setPastSessions(try await model.spool.archivedSessions())
|
||
try render(
|
||
PastSubmissionsView().environment(model),
|
||
to: directory.appendingPathComponent("panel-06b-past-submissions.png"),
|
||
width: 480
|
||
)
|
||
|
||
// 15 — the session details editor open, on the same real model: lane, deployed
|
||
// build, commit, reviewer and note are the values panel 04's session carries.
|
||
try render(
|
||
MenuBarView(showsContextEditor: true).environment(model),
|
||
to: directory.appendingPathComponent("panel-15-session-details.png")
|
||
)
|
||
|
||
// 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")
|
||
)
|
||
|
||
// 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")
|
||
)
|
||
|
||
// 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) throws {
|
||
let wrapped = view
|
||
.frame(width: width, alignment: .topLeading)
|
||
.fixedSize(horizontal: false, vertical: true)
|
||
.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: panelWidth, height: 64),
|
||
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 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()
|
||
RunLoop.current.run(until: Date(timeIntervalSinceNow: 0.05))
|
||
|
||
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)"
|
||
}
|
||
}
|
||
}
|