Publish VCC Plus OSS source distribution for 3.6.2 build 60
This commit is contained in:
commit
c652a5276d
1192 files changed
+272368
No files matched your search
@@ -0,0 +1,627 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
import SwiftUI
|
||||
import PDFKit
|
||||
import Compression
|
||||
|
||||
struct ArchiveAssetReceipt: Sendable {
|
||||
let url: URL
|
||||
let sha256: String
|
||||
let bytes: Int64
|
||||
let fileExtension: String
|
||||
let memberRange: ArchiveMemberRange?
|
||||
|
||||
init?(document: ArchiveDocument) {
|
||||
let sha = document.id
|
||||
guard sha.utf8.count == 64, sha.utf8.allSatisfy({ (48...57).contains($0) || (97...102).contains($0) }) else { return nil }
|
||||
if document.format == "pdf" {
|
||||
guard let url = document.deliveryURL, let bytes = document.deliveryBytes,
|
||||
bytes > 0, bytes <= 4 * 1024 * 1024 * 1024, Self.acceptsPDF(url) else { return nil }
|
||||
self.url = url
|
||||
self.bytes = bytes
|
||||
fileExtension = "pdf"
|
||||
memberRange = nil
|
||||
} else {
|
||||
guard let bytes = document.sourceBytes, bytes > 0, bytes <= 128 * 1024 * 1024,
|
||||
Self.acceptsSource(document.sourceURL) else { return nil }
|
||||
let ext: String
|
||||
if let member = document.memberPath {
|
||||
guard let range = document.memberRange, (0...1_073_741_824).contains(range.archiveBytes),
|
||||
range.offset >= 0, range.compressedBytes > 0, range.compressedBytes <= range.archiveBytes,
|
||||
range.offset <= range.archiveBytes - range.compressedBytes,
|
||||
range.method == 8 || (range.method == 0 && range.compressedBytes == bytes),
|
||||
document.sourceURL.pathExtension.lowercased() == "zip" else { return nil }
|
||||
ext = (member as NSString).pathExtension.lowercased()
|
||||
memberRange = range
|
||||
} else {
|
||||
ext = document.sourceURL.pathExtension.lowercased()
|
||||
memberRange = nil
|
||||
}
|
||||
switch document.format {
|
||||
case "image" where ["jpg","jpeg","gif","png","tif","tiff"].contains(ext): break
|
||||
case "text" where ["txt","bas"].contains(ext): break
|
||||
default: return nil
|
||||
}
|
||||
url = document.sourceURL
|
||||
self.bytes = bytes
|
||||
fileExtension = ext
|
||||
}
|
||||
sha256 = sha
|
||||
}
|
||||
|
||||
private static func acceptsPDF(_ url: URL) -> Bool {
|
||||
SoftwareLibraryInstaller.acceptsDownloadURL(url) && url.path.hasPrefix("/dl/software/CoCoLibrary/Documents/")
|
||||
&& url.pathExtension.lowercased() == "pdf"
|
||||
}
|
||||
|
||||
private static func acceptsSource(_ url: URL) -> Bool {
|
||||
url.scheme == "https" && url.host == "colorcomputerarchive.com" && url.user == nil && url.password == nil
|
||||
&& (url.port == nil || url.port == 443) && url.query == nil && url.fragment == nil
|
||||
&& url.path.hasPrefix("/repo/Documents/") && !url.pathComponents.contains("..") && !url.pathComponents.contains(".")
|
||||
&& !url.path.contains("\\") && !url.path.unicodeScalars.contains(where: CharacterSet.controlCharacters.contains)
|
||||
}
|
||||
|
||||
func acceptsResponseURL(_ url: URL) -> Bool {
|
||||
fileExtension == "pdf" ? Self.acceptsPDF(url) : Self.acceptsSource(url)
|
||||
}
|
||||
|
||||
var rangeHeader: String? {
|
||||
memberRange.map { "bytes=\($0.offset)-\($0.offset + $0.compressedBytes - 1)" }
|
||||
}
|
||||
|
||||
/// Servers may return the complete ZIP instead of honoring a byte-range request.
|
||||
func responseSize(_ response: HTTPURLResponse) -> Int64? {
|
||||
guard let final = response.url, acceptsResponseURL(final) else { return nil }
|
||||
guard let range = memberRange else { return response.statusCode == 200 ? bytes : nil }
|
||||
if response.statusCode == 200 { return range.archiveBytes }
|
||||
let header = "bytes \(range.offset)-\(range.offset + range.compressedBytes - 1)/\(range.archiveBytes)"
|
||||
return response.statusCode == 206 && response.value(forHTTPHeaderField: "Content-Range") == header ? range.compressedBytes : nil
|
||||
}
|
||||
}
|
||||
|
||||
private enum ArchiveReaderError: LocalizedError {
|
||||
case changed, unavailable, location, space, download, page
|
||||
var errorDescription: String? {
|
||||
switch self {
|
||||
case .changed: return "The downloaded file does not match the edition in the Archive index."
|
||||
case .unavailable: return "This edition is available at the Archive source."
|
||||
case .location: return "The Archive file could not be cached. Check the free space and permissions."
|
||||
case .space: return "There is not enough free space to cache this Archive file."
|
||||
case .download: return "The Archive file could not be downloaded. Check your connection and try again."
|
||||
case .page: return "This PDF could not be opened at the cited page. Use the Archive source to inspect the original."
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
enum ArchiveReadProgress: Sendable {
|
||||
case checking, downloading(Int64, Int64), verifying
|
||||
}
|
||||
|
||||
actor ArchiveAssetCache {
|
||||
#if VCC_UI_TESTING
|
||||
static let shared: ArchiveAssetCache = {
|
||||
let directory = ProcessInfo.processInfo.environment["VCC_ARCHIVE_TEST_CACHE"].map { URL(fileURLWithPath: $0, isDirectory: true) }
|
||||
?? FileManager.default.temporaryDirectory.appendingPathComponent("VCCArchiveUITest-" + UUID().uuidString, isDirectory: true)
|
||||
return ArchiveAssetCache(directory: directory)
|
||||
}()
|
||||
#else
|
||||
static let shared = ArchiveAssetCache()
|
||||
#endif
|
||||
private let directory: URL?
|
||||
private let configuration: URLSessionConfiguration
|
||||
|
||||
init(directory: URL? = nil, configuration: URLSessionConfiguration? = nil) {
|
||||
self.directory = directory
|
||||
if let configuration {
|
||||
self.configuration = configuration
|
||||
} else {
|
||||
let config = URLSessionConfiguration.ephemeral
|
||||
config.timeoutIntervalForRequest = 45
|
||||
config.timeoutIntervalForResource = 3600
|
||||
config.urlCache = nil
|
||||
self.configuration = config
|
||||
}
|
||||
}
|
||||
|
||||
func localCopy(_ receipt: ArchiveAssetReceipt, progress: @escaping @Sendable (ArchiveReadProgress) -> Void) async throws -> URL {
|
||||
try Task.checkCancellation()
|
||||
let fm = FileManager.default
|
||||
let directory = self.directory ?? AppIdentity.supportDirectory.appendingPathComponent(
|
||||
receipt.fileExtension == "pdf" ? "ArchiveLibrary/PDFs" : "ArchiveLibrary/Assets", isDirectory: true)
|
||||
try fm.createDirectory(at: directory, withIntermediateDirectories: true)
|
||||
let info = try directory.resourceValues(forKeys: [.isDirectoryKey, .isSymbolicLinkKey])
|
||||
guard info.isDirectory == true, info.isSymbolicLink != true else { throw ArchiveReaderError.location }
|
||||
let target = directory.appendingPathComponent(receipt.sha256 + "." + receipt.fileExtension)
|
||||
progress(.checking)
|
||||
if let attributes = try? fm.attributesOfItem(atPath: target.path) {
|
||||
guard attributes[.type] as? FileAttributeType == .typeRegular else { throw ArchiveReaderError.location }
|
||||
if (attributes[.size] as? NSNumber)?.int64Value == receipt.bytes,
|
||||
try SoftwareLibraryManualCache.fingerprint(target) == receipt.sha256 { return target }
|
||||
}
|
||||
let transferBytes = receipt.memberRange?.compressedBytes ?? receipt.bytes
|
||||
let disk = try fm.attributesOfFileSystem(forPath: directory.path)
|
||||
let free = (disk[.systemFreeSize] as? NSNumber)?.int64Value
|
||||
let reserved: Int64 = 32 * 1024 * 1024 + (receipt.memberRange == nil ? 0 : receipt.bytes)
|
||||
if let free, free < transferBytes + reserved { throw ArchiveReaderError.space }
|
||||
var request = URLRequest(url: receipt.url)
|
||||
request.setValue("VCCPlus/ArchiveLibrary", forHTTPHeaderField: "User-Agent")
|
||||
request.setValue("identity", forHTTPHeaderField: "Accept-Encoding")
|
||||
request.setValue(receipt.rangeHeader, forHTTPHeaderField: "Range")
|
||||
let temporary = directory.appendingPathComponent(UUID().uuidString + ".download")
|
||||
defer { try? fm.removeItem(at: temporary) }
|
||||
let observer = ArchiveAssetTransfer(receipt: receipt, available: free.map { $0 - reserved }, destination: temporary, progress: progress)
|
||||
progress(.downloading(0, transferBytes))
|
||||
let http = try await observer.download(request, configuration: configuration)
|
||||
try Task.checkCancellation()
|
||||
progress(.verifying)
|
||||
// Only atomically replace the cached edition after its final bytes have been verified.
|
||||
let staged = directory.appendingPathComponent(UUID().uuidString + ".partial")
|
||||
defer { try? fm.removeItem(at: staged) }
|
||||
if let range = receipt.memberRange {
|
||||
try Self.unpack(range, from: temporary, offset: http.statusCode == 206 ? 0 : range.offset, to: staged, bytes: receipt.bytes)
|
||||
} else {
|
||||
try fm.moveItem(at: temporary, to: staged)
|
||||
}
|
||||
guard try SoftwareLibraryManualCache.fingerprint(staged) == receipt.sha256 else { throw ArchiveReaderError.changed }
|
||||
try Task.checkCancellation()
|
||||
if fm.fileExists(atPath: target.path) {
|
||||
guard try fm.attributesOfItem(atPath: target.path)[.type] as? FileAttributeType == .typeRegular else { throw ArchiveReaderError.location }
|
||||
_ = try fm.replaceItemAt(target, withItemAt: staged)
|
||||
} else { try fm.moveItem(at: staged, to: target) }
|
||||
return target
|
||||
}
|
||||
|
||||
/// No archive paths become local filenames. Decode only the indexed member body
|
||||
/// and cap both compressed input and output, including the full-ZIP HTTP 200 path.
|
||||
private static func unpack(_ range: ArchiveMemberRange, from source: URL, offset: Int64, to output: URL, bytes: Int64) throws {
|
||||
let input = try FileHandle(forReadingFrom: source)
|
||||
defer { try? input.close() }
|
||||
try input.seek(toOffset: UInt64(offset))
|
||||
try Data().write(to: output, options: .withoutOverwriting)
|
||||
let writer = try FileHandle(forWritingTo: output)
|
||||
defer { try? writer.close() }
|
||||
var written: Int64 = 0
|
||||
func write(_ chunk: Data?) throws {
|
||||
try Task.checkCancellation()
|
||||
guard let chunk else { return }
|
||||
written += Int64(chunk.count)
|
||||
guard written <= bytes else { throw ArchiveReaderError.changed }
|
||||
try writer.write(contentsOf: chunk)
|
||||
}
|
||||
let decoder = range.method == 8 ? try OutputFilter(.decompress, using: .zlib, writingTo: write) : nil
|
||||
var remaining = range.compressedBytes
|
||||
while remaining > 0 {
|
||||
try Task.checkCancellation()
|
||||
guard let chunk = try input.read(upToCount: Int(min(remaining, 65536))), !chunk.isEmpty else { throw ArchiveReaderError.changed }
|
||||
remaining -= Int64(chunk.count)
|
||||
if let decoder { try decoder.write(chunk) } else { try write(chunk) }
|
||||
}
|
||||
try decoder?.finalize()
|
||||
guard written == bytes else { throw ArchiveReaderError.changed }
|
||||
}
|
||||
}
|
||||
|
||||
private final class ArchiveAssetTransfer: NSObject, URLSessionDownloadDelegate, @unchecked Sendable {
|
||||
private let receipt: ArchiveAssetReceipt
|
||||
private let available: Int64?
|
||||
private let destination: URL
|
||||
private let progress: @Sendable (ArchiveReadProgress) -> Void
|
||||
private let lock = NSLock() // Synchronizes task registration, cancellation, and completion.
|
||||
private var continuation: CheckedContinuation<HTTPURLResponse, Error>?
|
||||
// Foundation invokes the callbacks below on this session's serial delegate queue.
|
||||
private var rejection: ArchiveReaderError?
|
||||
private var lastReport: UInt64 = 0
|
||||
private var response: HTTPURLResponse?
|
||||
|
||||
init(receipt: ArchiveAssetReceipt, available: Int64?, destination: URL, progress: @escaping @Sendable (ArchiveReadProgress) -> Void) {
|
||||
self.receipt = receipt
|
||||
self.available = available
|
||||
self.destination = destination
|
||||
self.progress = progress
|
||||
}
|
||||
|
||||
func download(_ request: URLRequest, configuration: URLSessionConfiguration) async throws -> HTTPURLResponse {
|
||||
// The async download(for:) helper does not forward incremental download
|
||||
// callbacks. An explicit delegate task also lets us enforce the byte cap in flight.
|
||||
let session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
|
||||
defer { session.invalidateAndCancel() }
|
||||
let task = session.downloadTask(with: request)
|
||||
let result = try await withTaskCancellationHandler {
|
||||
try await withCheckedThrowingContinuation { (reply: CheckedContinuation<HTTPURLResponse, Error>) in
|
||||
lock.withLock {
|
||||
guard !Task.isCancelled else { reply.resume(throwing: CancellationError()); return }
|
||||
continuation = reply
|
||||
task.resume()
|
||||
}
|
||||
}
|
||||
} onCancel: {
|
||||
if self.lock.withLock({ self.continuation != nil }) { task.cancel() }
|
||||
}
|
||||
try Task.checkCancellation()
|
||||
return result
|
||||
}
|
||||
|
||||
func urlSession(_ session: URLSession, task: URLSessionTask, willPerformHTTPRedirection response: HTTPURLResponse,
|
||||
newRequest request: URLRequest, completionHandler: @escaping (URLRequest?) -> Void) {
|
||||
guard let url = request.url, receipt.acceptsResponseURL(url) else { completionHandler(nil); return }
|
||||
var redirected = request
|
||||
redirected.setValue(receipt.rangeHeader, forHTTPHeaderField: "Range")
|
||||
redirected.setValue("identity", forHTTPHeaderField: "Accept-Encoding")
|
||||
completionHandler(redirected)
|
||||
}
|
||||
|
||||
func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
|
||||
guard rejection == nil, let http = downloadTask.response as? HTTPURLResponse, let expected = receipt.responseSize(http) else {
|
||||
rejection = rejection ?? .download
|
||||
return
|
||||
}
|
||||
guard available.map({ expected <= $0 }) ?? true else { rejection = .space; return }
|
||||
do {
|
||||
guard (try location.resourceValues(forKeys: [.fileSizeKey]).fileSize).map(Int64.init) == expected else {
|
||||
rejection = .changed
|
||||
return
|
||||
}
|
||||
// Foundation removes its temporary file when this delegate method returns.
|
||||
try FileManager.default.moveItem(at: location, to: destination)
|
||||
response = http
|
||||
} catch { rejection = .location }
|
||||
}
|
||||
|
||||
func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
|
||||
let reply = lock.withLock {
|
||||
let reply = continuation
|
||||
continuation = nil
|
||||
return reply
|
||||
}
|
||||
if let rejection { reply?.resume(throwing: rejection) }
|
||||
else if (error as? URLError)?.code == .cancelled { reply?.resume(throwing: CancellationError()) }
|
||||
else if error == nil, let response { reply?.resume(returning: response) }
|
||||
else { reply?.resume(throwing: ArchiveReaderError.download) }
|
||||
}
|
||||
|
||||
func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didWriteData bytesWritten: Int64,
|
||||
totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64) {
|
||||
guard let response = downloadTask.response as? HTTPURLResponse, let expected = receipt.responseSize(response) else {
|
||||
rejection = .download
|
||||
downloadTask.cancel()
|
||||
return
|
||||
}
|
||||
guard totalBytesWritten <= expected, totalBytesExpectedToWrite <= expected else {
|
||||
rejection = .changed
|
||||
downloadTask.cancel()
|
||||
return
|
||||
}
|
||||
if let available, expected > available {
|
||||
rejection = .space
|
||||
downloadTask.cancel()
|
||||
return
|
||||
}
|
||||
let now = DispatchTime.now().uptimeNanoseconds
|
||||
guard lastReport == 0 || now - lastReport >= 120_000_000 || totalBytesWritten == expected else { return }
|
||||
lastReport = now
|
||||
progress(.downloading(totalBytesWritten, expected))
|
||||
}
|
||||
}
|
||||
|
||||
@MainActor
|
||||
final class ArchiveReaderModel: ObservableObject {
|
||||
let view = PDFView()
|
||||
@Published private(set) var referenceID: String?
|
||||
@Published private(set) var document: PDFDocument?
|
||||
@Published private(set) var preview: ArchiveInlineContent?
|
||||
@Published private(set) var sectionLabel: String?
|
||||
@Published private(set) var cancelled = false
|
||||
@Published private(set) var progress: ArchiveReadProgress?
|
||||
@Published private(set) var error: String?
|
||||
@Published private(set) var page = 1
|
||||
@Published var find = "" { didSet { if find != oldValue { resetFind() } } }
|
||||
@Published private(set) var findMessage: String?
|
||||
@Published private(set) var isFinding = false
|
||||
private var request: Task<Void, Never>?
|
||||
private var findTask: Task<Void, Never>?
|
||||
private var findRequestID = UUID()
|
||||
private var requestID = UUID()
|
||||
private var localURL: URL?
|
||||
private var lastMatch: (page: Int, range: NSRange)?
|
||||
private var pendingPage = 1
|
||||
let remembersPage: Bool
|
||||
private let cache: ArchiveAssetCache
|
||||
private let catalog: ArchiveLibraryCatalog
|
||||
|
||||
init(remembersPage: Bool, cache: ArchiveAssetCache = .shared, catalog: ArchiveLibraryCatalog = .shared) {
|
||||
self.remembersPage = remembersPage
|
||||
self.cache = cache
|
||||
self.catalog = catalog
|
||||
view.displayMode = .singlePageContinuous
|
||||
view.autoScales = true
|
||||
view.displaysPageBreaks = true
|
||||
view.setAccessibilityLabel("Archive PDF")
|
||||
}
|
||||
func stop() {
|
||||
requestID = UUID(); request?.cancel(); request = nil; progress = nil
|
||||
resetFind()
|
||||
}
|
||||
func reset() {
|
||||
stop()
|
||||
document = nil; view.document = nil; preview = nil; sectionLabel = nil
|
||||
referenceID = nil; error = nil; localURL = nil; page = 1; find = ""; cancelled = false
|
||||
}
|
||||
func cancel() {
|
||||
stop()
|
||||
cancelled = true
|
||||
}
|
||||
func retry(_ record: ArchiveDocument) {
|
||||
open(record, page: pendingPage)
|
||||
}
|
||||
private func rememberPage() {
|
||||
if remembersPage, let referenceID { UserDefaults.standard.set(page, forKey: "archive-library.page." + referenceID) }
|
||||
}
|
||||
static func savedPage(for id: String) -> Int { max(UserDefaults.standard.integer(forKey: "archive-library.page." + id), 1) }
|
||||
func updatePage() {
|
||||
guard let document, let current = view.currentPage, current.document === document else { return }
|
||||
let index = document.index(for: current)
|
||||
guard index >= 0, index < document.pageCount else { return }
|
||||
page = index + 1
|
||||
rememberPage()
|
||||
}
|
||||
func go(to number: Int) {
|
||||
guard let document, number > 0, number <= document.pageCount, let target = document.page(at: number - 1) else { return }
|
||||
view.go(to: target); updatePage()
|
||||
}
|
||||
func open(_ record: ArchiveDocument, page number: Int) {
|
||||
if referenceID == record.id {
|
||||
if document != nil { go(to: number); return }
|
||||
if preview != nil && page == number { return }
|
||||
if progress != nil && (record.format == "pdf" || number == pendingPage) {
|
||||
pendingPage = number
|
||||
return
|
||||
}
|
||||
}
|
||||
reset()
|
||||
referenceID = record.id
|
||||
pendingPage = number
|
||||
let identity = requestID
|
||||
progress = .checking
|
||||
request = Task {
|
||||
do {
|
||||
switch record.format {
|
||||
case "pdf", "image", "text":
|
||||
guard let receipt = ArchiveAssetReceipt(document: record) else { throw ArchiveReaderError.unavailable }
|
||||
let url = try await cache.localCopy(receipt) { event in
|
||||
Task { @MainActor in
|
||||
guard self.requestID == identity, self.progress != nil else { return }
|
||||
self.progress = event
|
||||
}
|
||||
}
|
||||
try Task.checkCancellation()
|
||||
if record.format == "pdf" {
|
||||
let parsed = await Task.detached(priority: .userInitiated) { PDFDocument(url: url) }.value
|
||||
try Task.checkCancellation()
|
||||
let target = pendingPage
|
||||
guard let parsed, !parsed.isLocked, target > 0, target <= parsed.pageCount else { throw ArchiveReaderError.page }
|
||||
localURL = url; document = parsed; view.document = parsed; view.autoScales = true; go(to: target)
|
||||
} else {
|
||||
let content = try await ArchivePreviewDecoder.shared.read(url, format: record.format, number: number)
|
||||
try Task.checkCancellation()
|
||||
page = number; preview = content; rememberPage()
|
||||
}
|
||||
default:
|
||||
guard let section = try await catalog.readerSection(documentID: record.id, number: number) else {
|
||||
throw ArchiveReaderError.unavailable
|
||||
}
|
||||
try Task.checkCancellation()
|
||||
page = section.number; sectionLabel = section.label
|
||||
preview = record.format == "office-xls" ? .worksheet(section.text) : .text(section.text)
|
||||
rememberPage()
|
||||
}
|
||||
progress = nil
|
||||
} catch {
|
||||
guard requestID == identity else { return }
|
||||
progress = nil
|
||||
if !Task.isCancelled { self.error = error.localizedDescription }
|
||||
}
|
||||
}
|
||||
}
|
||||
private func resetFind() {
|
||||
findRequestID = UUID(); findTask?.cancel(); findTask = nil; isFinding = false; findMessage = nil; lastMatch = nil
|
||||
}
|
||||
func findNext() {
|
||||
guard let localURL, let document, !isFinding, !find.isEmpty else { return }
|
||||
let text = find, current = page
|
||||
let start = lastMatch.flatMap { $0.page == page ? NSMaxRange($0.range) : nil } ?? 0
|
||||
let identity = UUID(); findRequestID = identity; isFinding = true; findMessage = nil
|
||||
findTask = Task {
|
||||
let result = await Self.nextMatch(in: localURL, text: text, page: current, start: start)
|
||||
guard !Task.isCancelled, findRequestID == identity, self.document === document else { return }
|
||||
isFinding = false
|
||||
guard let (number, range) = result, let target = document.page(at: number - 1), let selection = target.selection(for: range) else {
|
||||
findMessage = "No matching text in the PDF’s text layer."; return
|
||||
}
|
||||
view.setCurrentSelection(selection, animate: false); view.go(to: selection); updatePage(); lastMatch = (number, range)
|
||||
}
|
||||
}
|
||||
private nonisolated static func nextMatch(in url: URL, text: String, page: Int, start: Int) async -> (Int, NSRange)? {
|
||||
guard let doc = PDFDocument(url: url), doc.pageCount > 0, page > 0, page <= doc.pageCount else { return nil }
|
||||
for offset in 0...doc.pageCount {
|
||||
if Task.isCancelled { return nil }
|
||||
let index = (page - 1 + offset) % doc.pageCount
|
||||
let match: NSRange? = autoreleasepool {
|
||||
guard let raw = doc.page(at: index)?.string as NSString? else { return nil }
|
||||
let lower = offset == 0 ? min(start, raw.length) : 0
|
||||
let upper = offset == doc.pageCount ? min(start, raw.length) : raw.length
|
||||
let range = raw.range(of: text, options: [.caseInsensitive], range: NSRange(location: lower, length: upper - lower))
|
||||
return range.location == NSNotFound ? nil : range
|
||||
}
|
||||
if let match { return (index + 1, match) }
|
||||
}
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
private struct ArchivePDFSurface: NSViewRepresentable {
|
||||
let view: PDFView
|
||||
func makeNSView(context: Context) -> PDFView { view }
|
||||
func updateNSView(_ nsView: PDFView, context: Context) {}
|
||||
}
|
||||
|
||||
struct ArchiveReaderPane: View {
|
||||
let record: ArchiveDocument
|
||||
let hit: ArchiveHit?
|
||||
@ObservedObject var reader: ArchiveReaderModel
|
||||
let requestedPage: Int
|
||||
let catalog: ArchiveLibraryCatalog
|
||||
@Environment(\.openWindow) private var openWindow
|
||||
@State private var examples: [ArchiveExample] = []
|
||||
@State private var exampleError: String?
|
||||
@State private var loadedExampleKey: String?
|
||||
@State private var copies: String?
|
||||
@State private var pageField = "1"
|
||||
@FocusState private var findFocused: Bool
|
||||
|
||||
private var isCurrent: Bool { reader.referenceID == record.id }
|
||||
private var loaded: Bool { isCurrent && reader.document != nil }
|
||||
private var visiblePage: Int? {
|
||||
guard record.format == "pdf" else { return nil }
|
||||
return loaded ? reader.page : (hit?.page ?? requestedPage)
|
||||
}
|
||||
private var exampleKey: String { record.id + "/" + String(visiblePage ?? 0) }
|
||||
private var atHit: Bool {
|
||||
guard let hit else { return false }
|
||||
if loaded || (isCurrent && reader.preview != nil) { return hit.locationNumber == reader.page }
|
||||
return true
|
||||
}
|
||||
private var source: URL {
|
||||
if atHit, let hit { return hit.sourceURL }
|
||||
guard record.memberPath == nil, record.sourceURL.pathExtension.lowercased() == "pdf", let visiblePage,
|
||||
var parts = URLComponents(url: record.sourceURL, resolvingAgainstBaseURL: false) else { return record.sourceURL }
|
||||
parts.fragment = "page=\(visiblePage)"; return parts.url ?? record.sourceURL
|
||||
}
|
||||
private var citation: String {
|
||||
if atHit, let hit { return hit.citation }
|
||||
return record.cite(visiblePage.map { "PDF page \($0)" } ?? (isCurrent ? reader.sectionLabel : nil), at: source)
|
||||
}
|
||||
var body: some View {
|
||||
VStack(alignment: .leading, spacing: 0) {
|
||||
VStack(alignment: .leading, spacing: 5) {
|
||||
Text(record.collection.replacingOccurrences(of: "/", with: " › ")).font(.caption).foregroundStyle(.secondary)
|
||||
Text(record.title).font(.title3.weight(.semibold)).lineLimit(3).textSelection(.enabled)
|
||||
if let member = record.memberPath { Text("ZIP member · " + member).font(.caption).textSelection(.enabled) }
|
||||
if atHit, let hit { Label(hit.locator + (hit.ocr ? " · OCR match" : ""), systemImage: "text.magnifyingglass").font(.caption).foregroundStyle(.secondary) }
|
||||
if loadedExampleKey == exampleKey, !examples.isEmpty { exampleActions }
|
||||
if let exampleError { Text(exampleError).font(.caption).foregroundStyle(.secondary) }
|
||||
}.padding(12)
|
||||
Divider()
|
||||
if loaded, let pdf = reader.document {
|
||||
VStack(spacing: 7) {
|
||||
HStack {
|
||||
Button { reader.go(to: reader.page - 1) } label: { Image(systemName: "chevron.left") }.accessibilityLabel("Previous PDF page").disabled(reader.page <= 1)
|
||||
TextField("Page", text: $pageField).frame(width: 46).accessibilityLabel("PDF page number").onSubmit {
|
||||
if let n = Int(pageField) { reader.go(to: min(max(n, 1), pdf.pageCount)) }; pageField = String(reader.page)
|
||||
}
|
||||
Text("of \(pdf.pageCount)").foregroundStyle(.secondary)
|
||||
Button { reader.go(to: reader.page + 1) } label: { Image(systemName: "chevron.right") }.accessibilityLabel("Next PDF page").disabled(reader.page >= pdf.pageCount)
|
||||
Spacer()
|
||||
Button { reader.view.zoomOut(nil) } label: { Image(systemName: "minus.magnifyingglass") }.accessibilityLabel("Zoom out")
|
||||
Button { reader.view.zoomIn(nil) } label: { Image(systemName: "plus.magnifyingglass") }.accessibilityLabel("Zoom in")
|
||||
Button("Fit") { reader.view.autoScales = true }.accessibilityLabel("Fit page")
|
||||
}
|
||||
HStack {
|
||||
Button { findFocused = true } label: { Image(systemName: "magnifyingglass") }
|
||||
.buttonStyle(.borderless).keyboardShortcut("f").accessibilityLabel("Focus Find in PDF")
|
||||
TextField("Find in PDF", text: $reader.find).focused($findFocused).onSubmit { reader.findNext() }.accessibilityIdentifier("archive-pdf-find")
|
||||
if reader.isFinding { ProgressView().controlSize(.small) }
|
||||
Button("Find Next") { reader.findNext() }.keyboardShortcut("g").disabled(reader.find.isEmpty || reader.isFinding)
|
||||
}
|
||||
if let message = reader.findMessage { Text(message).font(.caption).foregroundStyle(.secondary) }
|
||||
}.padding(8)
|
||||
ArchivePDFSurface(view: reader.view).id(ObjectIdentifier(reader.view)).accessibilityIdentifier("archive-pdf-surface")
|
||||
.onReceive(NotificationCenter.default.publisher(for: .PDFViewPageChanged, object: reader.view)) { _ in reader.updatePage() }
|
||||
} else if isCurrent, let preview = reader.preview {
|
||||
if let count = record.pageCount, count > 1 {
|
||||
HStack {
|
||||
Button { reader.open(record, page: reader.page - 1) } label: { Image(systemName: "chevron.left") }
|
||||
.accessibilityLabel("Previous section").disabled(reader.page <= 1)
|
||||
TextField("Section", text: $pageField).frame(width: 44).accessibilityLabel("Section number").onSubmit {
|
||||
if let n = Int(pageField) { reader.open(record, page: min(max(n, 1), count)) }
|
||||
pageField = String(reader.page)
|
||||
}
|
||||
Text("of \(count)")
|
||||
Button { reader.open(record, page: reader.page + 1) } label: { Image(systemName: "chevron.right") }
|
||||
.accessibilityLabel("Next section").disabled(reader.page >= count)
|
||||
if let label = reader.sectionLabel { Text(label).lineLimit(2).help(label) }
|
||||
Spacer(minLength: 0)
|
||||
}.padding(8)
|
||||
}
|
||||
ArchiveInlinePreview(content: preview, title: record.title)
|
||||
.id(record.id + "/" + String(reader.page))
|
||||
} else {
|
||||
VStack(spacing: 12) {
|
||||
if isCurrent, let progress = reader.progress {
|
||||
switch progress {
|
||||
case .checking: ProgressView("Opening document…")
|
||||
case .verifying: ProgressView("Verifying download…")
|
||||
case .downloading(let done, let total):
|
||||
ProgressView(value: Double(done), total: Double(total)) { Text("Downloading…") }
|
||||
Text(ByteCountFormatter.string(fromByteCount: done, countStyle: .file) + " of " + ByteCountFormatter.string(fromByteCount: total, countStyle: .file)).font(.caption).monospacedDigit()
|
||||
}
|
||||
Button("Cancel") { reader.cancel() }
|
||||
} else if isCurrent, reader.error != nil || reader.cancelled {
|
||||
Text(reader.error ?? "Loading cancelled.").multilineTextAlignment(.center)
|
||||
Button("Try Again") { reader.retry(record) }
|
||||
} else {
|
||||
ProgressView("Opening document…")
|
||||
}
|
||||
}.padding(16).frame(maxWidth: .infinity, maxHeight: .infinity)
|
||||
}
|
||||
Divider()
|
||||
HStack {
|
||||
VStack(alignment: .leading, spacing: 3) {
|
||||
Text("Color Computer Archive").font(.caption).foregroundStyle(.secondary)
|
||||
Link("Archive source", destination: source)
|
||||
}
|
||||
Spacer()
|
||||
if let copies { Text(copies).font(.caption).foregroundStyle(.secondary) }
|
||||
Button("Copy Citation") { copy(citation, success: "Citation copied") }.accessibilityIdentifier("archive-copy-citation")
|
||||
}.padding(10)
|
||||
}
|
||||
.onChange(of: reader.page, initial: true) { _, value in pageField = String(value) }
|
||||
.task(id: hit?.id ?? record.id) {
|
||||
guard !Task.isCancelled else { return }
|
||||
reader.open(record, page: requestedPage)
|
||||
}
|
||||
.task(id: exampleKey) {
|
||||
examples = []; loadedExampleKey = nil; exampleError = nil; copies = nil
|
||||
guard let page = visiblePage else { return }
|
||||
do {
|
||||
let entries = try await catalog.examples(documentID: record.id, page: page)
|
||||
try Task.checkCancellation()
|
||||
examples = entries; loadedExampleKey = exampleKey
|
||||
} catch { if !Task.isCancelled { exampleError = "Example information could not be read." } }
|
||||
}
|
||||
}
|
||||
@ViewBuilder private var exampleActions: some View {
|
||||
if let first = examples.first, examples.count == 1 {
|
||||
HStack {
|
||||
Button(first.kind == "snippet" ? "Copy Snippet" : "Copy Example") { copy(first.source, success: "Source copied") }
|
||||
.help(first.title + " · " + first.author + "\n" + first.provenance)
|
||||
if first.kind == "basic_program" { Button("Open in BASIC Editor") { openExample(first) } }
|
||||
Menu { Text(first.title); Text(first.language); Text(first.author); Text(first.provenance) } label: { Image(systemName: "info.circle") }
|
||||
.menuStyle(.borderlessButton).fixedSize().accessibilityLabel("Example source information")
|
||||
}
|
||||
} else {
|
||||
Menu("Examples on this page") {
|
||||
ForEach(examples) { item in
|
||||
Menu(item.title) {
|
||||
Button(item.kind == "snippet" ? "Copy Snippet" : "Copy Example") { copy(item.source, success: "Source copied") }
|
||||
if item.kind == "basic_program" { Button("Open in BASIC Editor") { openExample(item) } }
|
||||
Divider(); Text(item.author); Text(item.language); Text(item.provenance)
|
||||
}
|
||||
}
|
||||
}.fixedSize().accessibilityIdentifier("archive-examples")
|
||||
}
|
||||
}
|
||||
private func openExample(_ item: ArchiveExample) { openWindow(id: "basic-example", value: "archive/" + item.sourceSHA256) }
|
||||
private func copy(_ text: String, success: String) {
|
||||
let pasteboard = NSPasteboard.general
|
||||
pasteboard.clearContents(); copies = pasteboard.setString(text, forType: .string) ? success : "Copy failed"
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user