1251 lines
44 KiB
Swift
1251 lines
44 KiB
Swift
import AppKit
|
|
import SwiftUI
|
|
|
|
struct DirectoryPreviewEntry: Identifiable {
|
|
let id = UUID()
|
|
let name: String
|
|
let isDirectory: Bool
|
|
}
|
|
|
|
struct ItemDetailColumnView: View {
|
|
let item: MinecraftContentItem?
|
|
let source: MinecraftSource?
|
|
let showsSourceDetails: Bool
|
|
let behaviorPacks: [ContentPackReference]
|
|
let resourcePacks: [ContentPackReference]
|
|
let worldsUsingPack: [MinecraftContentItem]
|
|
let backingPackInstances: [MinecraftContentItem]
|
|
let isSuspiciousPack: Bool
|
|
let contents: [DirectoryPreviewEntry]
|
|
let directoryPreviewLimit: Int
|
|
let isEmpty: Bool
|
|
let isPerformingItemAction: Bool
|
|
let areFileActionsEnabled: Bool
|
|
let exportTitle: String?
|
|
let exportAction: () -> Void
|
|
let revealAction: () -> Void
|
|
let shareAction: (NSView?) -> Void
|
|
|
|
var body: some View {
|
|
Group {
|
|
if isEmpty {
|
|
// Text("Add a source folder to start scanning your Minecraft library")
|
|
// .foregroundStyle(.secondary)
|
|
} else if let item {
|
|
ItemDetailView(
|
|
item: item,
|
|
source: source,
|
|
behaviorPacks: behaviorPacks,
|
|
resourcePacks: resourcePacks,
|
|
worldsUsingPack: worldsUsingPack,
|
|
backingPackInstances: backingPackInstances,
|
|
isSuspiciousPack: isSuspiciousPack,
|
|
contents: contents,
|
|
directoryPreviewLimit: directoryPreviewLimit,
|
|
isPerformingItemAction: isPerformingItemAction,
|
|
areFileActionsEnabled: areFileActionsEnabled,
|
|
exportTitle: exportTitle,
|
|
exportAction: exportAction,
|
|
revealAction: revealAction,
|
|
shareAction: shareAction
|
|
)
|
|
} else if showsSourceDetails, let source {
|
|
SourceDetailView(source: source)
|
|
} else {
|
|
Text("Select a world or pack to see details")
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
.toolbar {
|
|
if item != nil {
|
|
ToolbarItem {
|
|
Button(action: exportAction) {
|
|
Image(systemName: "arrow.down.circle")
|
|
}
|
|
.disabled(isPerformingItemAction || !areFileActionsEnabled)
|
|
.help(exportTitle ?? "Export")
|
|
}
|
|
|
|
ToolbarItem {
|
|
Button(action: revealAction) {
|
|
Image(systemName: "folder")
|
|
}
|
|
.disabled(isPerformingItemAction || !areFileActionsEnabled)
|
|
.help("Reveal in Finder")
|
|
}
|
|
|
|
ToolbarItem {
|
|
ToolbarShareButton(
|
|
systemImage: "square.and.arrow.up",
|
|
isEnabled: !isPerformingItemAction && areFileActionsEnabled
|
|
) { anchorView in
|
|
shareAction(anchorView)
|
|
}
|
|
.help("Share")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private struct SourceDetailView: View {
|
|
private enum StageStatus {
|
|
case pending
|
|
case inProgress
|
|
case completed
|
|
}
|
|
|
|
private struct StageRow: Identifiable {
|
|
let id: String
|
|
let title: String
|
|
let detail: String
|
|
let status: StageStatus
|
|
let progress: Double?
|
|
let showsIndeterminateProgress: Bool
|
|
}
|
|
|
|
let source: MinecraftSource
|
|
|
|
var body: some View {
|
|
ScrollView {
|
|
VStack(alignment: .leading, spacing: 24) {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text(source.displayName)
|
|
.font(.largeTitle.weight(.semibold))
|
|
|
|
Text(sourceSummary)
|
|
.font(.subheadline)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
|
|
if showsStatusSection {
|
|
sourceStatusSection
|
|
}
|
|
|
|
sourceSection(title: "Overview", rows: overviewRows)
|
|
sourceSection(title: "Contents", rows: contentRows)
|
|
sourceSection(title: "Location", rows: locationRows)
|
|
|
|
if !technicalRows.isEmpty {
|
|
sourceSection(title: "Technical Details", rows: technicalRows)
|
|
}
|
|
}
|
|
.frame(maxWidth: 760, alignment: .leading)
|
|
.padding(28)
|
|
}
|
|
}
|
|
|
|
private var sourceSummary: String {
|
|
switch source.origin {
|
|
case .localFolder:
|
|
return "Local filesystem source"
|
|
case .connectedDevice(let device, let container):
|
|
return "\(device.name) • \(container.appName)"
|
|
}
|
|
}
|
|
|
|
private var showsStatusSection: Bool {
|
|
if source.isScanning || source.scanError != nil || source.availability != .available {
|
|
return true
|
|
}
|
|
|
|
guard !source.scanStatus.isEmpty else {
|
|
return false
|
|
}
|
|
|
|
if source.scanStatus == "No Minecraft items found." {
|
|
return false
|
|
}
|
|
|
|
if source.scanStatus.hasPrefix("Loaded ") {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
private var statusTitle: String {
|
|
if !source.isScanning, source.availability != .available {
|
|
return source.availabilityDisplayText
|
|
}
|
|
|
|
if let scanError = source.scanError, !scanError.isEmpty {
|
|
return "Scan Failed"
|
|
}
|
|
|
|
if source.isScanning {
|
|
return source.liveScanStatusTitle
|
|
}
|
|
|
|
if !source.scanStatus.isEmpty {
|
|
return source.scanStatus
|
|
}
|
|
|
|
return "Scanning Minecraft library..."
|
|
}
|
|
|
|
private var statusDetail: String? {
|
|
if !source.isScanning, source.availability != .available {
|
|
if let scanDiagnostic = source.scanDiagnostic, !scanDiagnostic.isEmpty {
|
|
return scanDiagnostic
|
|
}
|
|
|
|
if let cachedAvailabilityDetailText = source.cachedAvailabilityDetailText {
|
|
return cachedAvailabilityDetailText
|
|
}
|
|
|
|
if let lastScanDate = source.lastScanDate {
|
|
return "Cached from \(lastScanDate.formatted(date: .abbreviated, time: .shortened))"
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
if let scanError = source.scanError, !scanError.isEmpty {
|
|
return scanError
|
|
}
|
|
|
|
if let diagnostic = source.scanDiagnostic, !diagnostic.isEmpty {
|
|
return diagnostic
|
|
}
|
|
|
|
if source.isScanning {
|
|
return nil
|
|
}
|
|
|
|
return "\(source.indexedDetailCount) of \(source.indexedItemCount) indexed"
|
|
}
|
|
|
|
@ViewBuilder
|
|
private var sourceStatusSection: some View {
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
Text("Status")
|
|
.font(.headline)
|
|
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
HStack(alignment: .center, spacing: 10) {
|
|
if source.showsIndeterminateScanActivityIndicator {
|
|
ProgressView()
|
|
.controlSize(.small)
|
|
} else if !source.isScanning {
|
|
sourceStatusIcon
|
|
}
|
|
|
|
Text(statusTitle)
|
|
.font(.subheadline.weight(.semibold))
|
|
}
|
|
|
|
if let statusDetail, !statusDetail.isEmpty {
|
|
Text(statusDetail)
|
|
.font(.subheadline)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
|
|
if source.isScanning {
|
|
Divider()
|
|
.padding(.vertical, 2)
|
|
|
|
VStack(alignment: .leading, spacing: 10) {
|
|
ForEach(stageRows) { stage in
|
|
sourceStageRow(stage)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.padding(18)
|
|
.background(.regularMaterial, in: RoundedRectangle(cornerRadius: 18, style: .continuous))
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private var sourceStatusIcon: some View {
|
|
if source.availability == .limited {
|
|
Image(systemName: "lock.circle.fill")
|
|
.foregroundStyle(Color.appAccent)
|
|
} else if source.availability != .available {
|
|
Image(systemName: source.isOfflineCached ? "externaldrive.badge.exclamationmark" : "slash.circle")
|
|
.foregroundStyle(.secondary)
|
|
} else if source.scanError != nil {
|
|
Image(systemName: "exclamationmark.triangle.fill")
|
|
.foregroundStyle(.orange)
|
|
} else {
|
|
Image(systemName: "info.circle")
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
|
|
private var overviewRows: [(String, String)] {
|
|
var rows: [(String, String)] = [
|
|
("Type", sourceTypeLabel),
|
|
("Availability", availabilityLabel)
|
|
]
|
|
|
|
if let lastScanDate = source.lastScanDate {
|
|
rows.append(("Last Successful Scan", lastScanDate.formatted(date: .abbreviated, time: .shortened)))
|
|
}
|
|
|
|
switch source.origin {
|
|
case .localFolder:
|
|
break
|
|
case .connectedDevice(let device, let container):
|
|
rows.append(("Connection", device.connection == .network ? "Network" : "USB"))
|
|
rows.append(("App Container", container.appName))
|
|
if let osVersion = device.osVersion, !osVersion.isEmpty {
|
|
rows.append(("OS Version", osVersion))
|
|
}
|
|
}
|
|
|
|
return rows
|
|
}
|
|
|
|
private var contentRows: [(String, String)] {
|
|
[
|
|
("Total Items", source.items.count.formatted(.number)),
|
|
("Worlds", itemCount(for: .world).formatted(.number)),
|
|
("Behavior Packs", itemCount(for: .behaviorPack).formatted(.number)),
|
|
("Resource Packs", itemCount(for: .resourcePack).formatted(.number)),
|
|
("Skin Packs", itemCount(for: .skinPack).formatted(.number)),
|
|
("World Templates", itemCount(for: .worldTemplate).formatted(.number))
|
|
]
|
|
}
|
|
|
|
private var locationRows: [(String, String)] {
|
|
switch source.origin {
|
|
case .localFolder:
|
|
return [("Filesystem Path", source.folderURL.path)]
|
|
case .connectedDevice(_, let container):
|
|
var rows: [(String, String)] = [
|
|
("Source Identifier", source.folderURL.absoluteString)
|
|
]
|
|
if let relativePath = container.minecraftFolderRelativePath, !relativePath.isEmpty {
|
|
rows.append(("Minecraft Path", relativePath))
|
|
}
|
|
return rows
|
|
}
|
|
}
|
|
|
|
private var technicalRows: [(String, String)] {
|
|
switch source.origin {
|
|
case .localFolder:
|
|
return []
|
|
case .connectedDevice(let device, let container):
|
|
var rows: [(String, String)] = [
|
|
("UDID", device.udid),
|
|
("App ID", container.appID),
|
|
("Access Mode", container.accessMode.rawValue)
|
|
]
|
|
if let productType = device.productType, !productType.isEmpty {
|
|
rows.append(("Product Type", productType))
|
|
}
|
|
rows.append(("Trust State", device.trustState.rawValue.capitalized))
|
|
return rows
|
|
}
|
|
}
|
|
|
|
private var sourceTypeLabel: String {
|
|
switch source.origin {
|
|
case .localFolder:
|
|
return "Local Folder"
|
|
case .connectedDevice:
|
|
return "Connected Device"
|
|
}
|
|
}
|
|
|
|
private var availabilityLabel: String {
|
|
switch source.availability {
|
|
case .unknown:
|
|
return "Unknown"
|
|
case .available:
|
|
return "Available"
|
|
case .disconnected:
|
|
return "Disconnected"
|
|
case .limited:
|
|
return "Limited"
|
|
case .unavailable:
|
|
return "Unavailable"
|
|
}
|
|
}
|
|
|
|
private var stageRows: [StageRow] {
|
|
[
|
|
previewStageRow,
|
|
sizeStageRow
|
|
]
|
|
}
|
|
|
|
private var previewStageRow: StageRow {
|
|
let total = source.indexedItemCount
|
|
let progress = total > 0 ? min(Double(source.previewLoadedCount) / Double(total), 1) : 0
|
|
let hasPreviewWorkStarted = source.previewLoadedCount > 0 || source.scanStatus.contains("Loading previews")
|
|
let previewsAreFullyLoaded = total > 0 && source.previewLoadedCount >= total
|
|
let shouldShowIndeterminatePreviewProgress = hasPreviewWorkStarted
|
|
&& source.isScanning
|
|
&& (source.scanProgress ?? 0) < 0.65
|
|
|
|
let status: StageStatus
|
|
if previewsAreFullyLoaded || source.scanPhase == .sizing || source.scanPhase == .completed {
|
|
status = .completed
|
|
} else if hasPreviewWorkStarted {
|
|
status = .inProgress
|
|
} else {
|
|
status = .pending
|
|
}
|
|
|
|
let detail: String
|
|
switch status {
|
|
case .completed:
|
|
detail = finishedStageDetail(duration: source.previewStageDuration ?? source.previewStageElapsed)
|
|
case .inProgress:
|
|
detail = stageProgressDetail(
|
|
completed: source.previewLoadedCount,
|
|
total: total,
|
|
unit: "previews loaded",
|
|
elapsed: source.previewStageElapsed
|
|
)
|
|
case .pending:
|
|
detail = "Waiting for discovery to finish"
|
|
}
|
|
|
|
return StageRow(
|
|
id: "previews",
|
|
title: "Previews",
|
|
detail: detail,
|
|
status: status,
|
|
progress: status == .completed ? 1 : progress,
|
|
showsIndeterminateProgress: shouldShowIndeterminatePreviewProgress
|
|
)
|
|
}
|
|
|
|
private var sizeStageRow: StageRow {
|
|
let total = source.indexedItemCount
|
|
let progress = total > 0 ? min(Double(source.sizeLoadedCount) / Double(total), 1) : 0
|
|
let previewsAreFullyLoaded = total > 0 && source.previewLoadedCount >= total
|
|
|
|
let status: StageStatus
|
|
switch source.scanPhase {
|
|
case .sizing:
|
|
status = .inProgress
|
|
case .completed:
|
|
status = .completed
|
|
case .discovering, .metadata, .previews, .idle:
|
|
status = .pending
|
|
}
|
|
|
|
let detail: String
|
|
switch status {
|
|
case .completed:
|
|
detail = finishedStageDetail(duration: source.sizeStageDuration)
|
|
case .inProgress:
|
|
detail = stageProgressDetail(
|
|
completed: source.sizeLoadedCount,
|
|
total: total,
|
|
unit: "sizes calculated",
|
|
elapsed: source.sizeStageElapsed
|
|
)
|
|
case .pending:
|
|
detail = previewsAreFullyLoaded
|
|
? "Preparing size calculations..."
|
|
: "Waiting for previews to finish loading"
|
|
}
|
|
|
|
return StageRow(
|
|
id: "sizes",
|
|
title: "Sizes",
|
|
detail: detail,
|
|
status: status,
|
|
progress: status == .completed ? 1 : progress,
|
|
showsIndeterminateProgress: false
|
|
)
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func sourceStageRow(_ stage: StageRow) -> some View {
|
|
VStack(alignment: .leading, spacing: 6) {
|
|
HStack(alignment: .firstTextBaseline, spacing: 10) {
|
|
Image(systemName: stageIconName(for: stage.status))
|
|
.font(.system(size: 11, weight: .semibold))
|
|
.foregroundStyle(stageIconColor(for: stage.status))
|
|
.frame(width: 14)
|
|
|
|
Text(stage.title)
|
|
.font(.subheadline.weight(.semibold))
|
|
|
|
Spacer()
|
|
|
|
Text(stage.detail)
|
|
.font(.caption)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
|
|
if stage.status == .completed {
|
|
EmptyView()
|
|
} else if stage.showsIndeterminateProgress {
|
|
ProgressView()
|
|
.progressViewStyle(.linear)
|
|
.controlSize(.small)
|
|
.tint(Color.appAccent)
|
|
} else if let progress = stage.progress {
|
|
ProgressView(value: progress, total: 1)
|
|
.tint(stage.status == .pending ? .secondary.opacity(0.35) : Color.appAccent)
|
|
.opacity(stage.status == .pending ? 0.55 : 1)
|
|
}
|
|
}
|
|
}
|
|
|
|
private func stageIconName(for status: StageStatus) -> String {
|
|
switch status {
|
|
case .pending:
|
|
return "circle"
|
|
case .inProgress:
|
|
return "clock"
|
|
case .completed:
|
|
return "checkmark.circle.fill"
|
|
}
|
|
}
|
|
|
|
private func stageIconColor(for status: StageStatus) -> Color {
|
|
switch status {
|
|
case .pending:
|
|
return .secondary.opacity(0.7)
|
|
case .inProgress:
|
|
return Color.appAccent
|
|
case .completed:
|
|
return .green
|
|
}
|
|
}
|
|
|
|
private func stageProgressDetail(
|
|
completed: Int,
|
|
total: Int,
|
|
unit: String,
|
|
elapsed: TimeInterval?
|
|
) -> String {
|
|
guard total > 0 else {
|
|
return "Starting..."
|
|
}
|
|
|
|
var detail = "\(completed) of \(total) \(unit)"
|
|
|
|
if let remainingEstimate = estimateRemainingTime(
|
|
completed: completed,
|
|
total: total,
|
|
elapsed: elapsed
|
|
) {
|
|
detail += " • about \(friendlyDuration(remainingEstimate)) left"
|
|
}
|
|
|
|
return detail
|
|
}
|
|
|
|
private func finishedStageDetail(duration: TimeInterval?) -> String {
|
|
guard let duration else {
|
|
return "Finished"
|
|
}
|
|
|
|
return "Finished in \(friendlyDuration(duration))"
|
|
}
|
|
|
|
private func estimateRemainingTime(
|
|
completed: Int,
|
|
total: Int,
|
|
elapsed: TimeInterval?
|
|
) -> TimeInterval? {
|
|
guard
|
|
let elapsed,
|
|
elapsed >= 10,
|
|
completed >= 10,
|
|
total > 0,
|
|
completed < total
|
|
else {
|
|
return nil
|
|
}
|
|
|
|
let completionFraction = Double(completed) / Double(total)
|
|
guard completionFraction >= 0.05 else {
|
|
return nil
|
|
}
|
|
|
|
let secondsPerItem = elapsed / Double(completed)
|
|
let remaining = max(Double(total - completed) * secondsPerItem, 1)
|
|
guard remaining >= 60 else {
|
|
return nil
|
|
}
|
|
|
|
return remaining
|
|
}
|
|
|
|
private func friendlyDuration(_ duration: TimeInterval) -> String {
|
|
let formatter = DateComponentsFormatter()
|
|
formatter.unitsStyle = .full
|
|
formatter.maximumUnitCount = duration >= 3600 ? 2 : 1
|
|
formatter.allowedUnits = duration >= 3600 ? [.hour, .minute] : duration >= 60 ? [.minute] : [.second]
|
|
formatter.includesApproximationPhrase = false
|
|
formatter.includesTimeRemainingPhrase = false
|
|
return formatter.string(from: duration) ?? "a moment"
|
|
}
|
|
|
|
private func itemCount(for type: MinecraftContentType) -> Int {
|
|
source.items.filter { $0.contentType == type }.count
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func sourceSection(title: String, rows: [(String, String)]) -> some View {
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
Text(title)
|
|
.font(.headline)
|
|
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
ForEach(Array(rows.enumerated()), id: \.offset) { _, row in
|
|
HStack(alignment: .top, spacing: 16) {
|
|
Text(row.0)
|
|
.font(.subheadline.weight(.semibold))
|
|
.foregroundStyle(.secondary)
|
|
.frame(width: 170, alignment: .leading)
|
|
|
|
Text(row.1)
|
|
.textSelection(.enabled)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
}
|
|
}
|
|
.padding(18)
|
|
.background(.regularMaterial, in: RoundedRectangle(cornerRadius: 18, style: .continuous))
|
|
}
|
|
}
|
|
}
|
|
|
|
struct ItemDetailView: View {
|
|
private let detailContentMaxWidth: CGFloat = 760
|
|
private let heroContentMaxWidth: CGFloat = 1080
|
|
|
|
let item: MinecraftContentItem
|
|
let source: MinecraftSource?
|
|
let behaviorPacks: [ContentPackReference]
|
|
let resourcePacks: [ContentPackReference]
|
|
let worldsUsingPack: [MinecraftContentItem]
|
|
let backingPackInstances: [MinecraftContentItem]
|
|
let isSuspiciousPack: Bool
|
|
let contents: [DirectoryPreviewEntry]
|
|
let directoryPreviewLimit: Int
|
|
let isPerformingItemAction: Bool
|
|
let areFileActionsEnabled: Bool
|
|
let exportTitle: String?
|
|
let exportAction: () -> Void
|
|
let revealAction: () -> Void
|
|
let shareAction: (NSView?) -> Void
|
|
@State private var storageBreakdown = StorageBreakdown.loading
|
|
|
|
var body: some View {
|
|
ScrollView {
|
|
VStack(alignment: .leading, spacing: 0) {
|
|
heroSection
|
|
|
|
VStack(alignment: .leading, spacing: 28) {
|
|
recordSection(title: "About") {
|
|
summaryGrid
|
|
}
|
|
|
|
if !worldSettingsRows.isEmpty {
|
|
recordSection(title: "World Settings") {
|
|
VStack(alignment: .leading, spacing: 14) {
|
|
ForEach(worldSettingsRows, id: \.title) { row in
|
|
detailValueRow(title: row.title, value: row.value)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if let healthMessages, !healthMessages.isEmpty {
|
|
recordSection(title: "Compatibility") {
|
|
VStack(alignment: .leading, spacing: 10) {
|
|
ForEach(healthMessages, id: \.self) { message in
|
|
Label(message, systemImage: "exclamationmark.triangle")
|
|
.font(.subheadline)
|
|
.foregroundStyle(.orange)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if item.contentType == .world, !behaviorPacks.isEmpty || !resourcePacks.isEmpty || !relationshipHighlights.isEmpty {
|
|
recordSection(title: "Packs Used") {
|
|
VStack(alignment: .leading, spacing: 16) {
|
|
if !relationshipHighlights.isEmpty {
|
|
summaryLines(relationshipHighlights)
|
|
}
|
|
|
|
if !behaviorPacks.isEmpty {
|
|
packSection(title: "Behavior Packs", packs: behaviorPacks)
|
|
}
|
|
|
|
if !resourcePacks.isEmpty {
|
|
packSection(title: "Resource Packs", packs: resourcePacks)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (item.contentType == .behaviorPack || item.contentType == .resourcePack), !worldsUsingPack.isEmpty {
|
|
recordSection(title: "Used By Worlds") {
|
|
VStack(alignment: .leading, spacing: 14) {
|
|
summaryLines(packUsageHighlights)
|
|
|
|
ForEach(worldsUsingPack) { world in
|
|
recordListRow(
|
|
title: world.displayName,
|
|
subtitle: worldUsageSecondaryText(for: world),
|
|
iconURL: world.iconURL,
|
|
fallbackSystemImage: "globe.europe.africa"
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (item.contentType == .behaviorPack || item.contentType == .resourcePack), !backingPackInstances.isEmpty {
|
|
recordSection(title: "Pack Instances") {
|
|
VStack(alignment: .leading, spacing: 14) {
|
|
summaryLines(instanceHighlights)
|
|
|
|
ForEach(backingPackInstances) { instance in
|
|
recordListRow(
|
|
title: instance.folderName,
|
|
subtitle: packInstanceSecondaryText(for: instance),
|
|
iconURL: instance.iconURL,
|
|
fallbackSystemImage: fallbackIconName
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
recordSection(title: "Storage") {
|
|
VStack(alignment: .leading, spacing: 14) {
|
|
if !storageHighlights.isEmpty {
|
|
summaryLines(storageHighlights)
|
|
}
|
|
|
|
detailValueRow(title: "Primary Data", value: storageBreakdown.primaryDataText)
|
|
detailValueRow(title: "Resources", value: storageBreakdown.resourcesText)
|
|
detailValueRow(title: "Metadata", value: storageBreakdown.metadataText)
|
|
detailValueRow(title: "Artwork", value: item.iconURL == nil ? "No icon found" : "Thumbnail found")
|
|
}
|
|
}
|
|
|
|
recordSection(title: "Locations") {
|
|
VStack(alignment: .leading, spacing: 14) {
|
|
detailRow(title: "Source Library", value: source?.displayName ?? item.collectionRootURL.deletingLastPathComponent().lastPathComponent)
|
|
detailRow(title: "Record Path", value: item.folderURL.path)
|
|
detailRow(title: "Collection Root", value: item.collectionRootURL.path)
|
|
}
|
|
}
|
|
|
|
recordSection(title: "Activity") {
|
|
VStack(alignment: .leading, spacing: 14) {
|
|
detailValueRow(title: "Indexed", value: source?.lastScanDate?.formatted(date: .abbreviated, time: .shortened) ?? "Unknown")
|
|
detailValueRow(title: "Visible Items", value: visibleContentsCountText)
|
|
|
|
if !contents.isEmpty {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text("Recent Folder Contents")
|
|
.font(.subheadline.weight(.semibold))
|
|
|
|
ForEach(contents) { entry in
|
|
HStack(spacing: 10) {
|
|
Image(systemName: entry.isDirectory ? "folder.fill" : "doc.text")
|
|
.foregroundStyle(.secondary)
|
|
Text(entry.name)
|
|
.lineLimit(1)
|
|
Spacer()
|
|
}
|
|
}
|
|
|
|
if contents.count == directoryPreviewLimit {
|
|
Text("Showing the first \(directoryPreviewLimit) items")
|
|
.font(.caption)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
recordSection(title: "Technical Details") {
|
|
VStack(alignment: .leading, spacing: 14) {
|
|
detailRow(title: "Folder ID", value: item.folderID)
|
|
detailRow(title: "Type", value: item.contentType.rawValue)
|
|
detailRow(title: "Collection Folder", value: item.collectionRootURL.lastPathComponent)
|
|
if let spawn = item.worldMetadata?.spawn {
|
|
detailValueRow(title: "Spawn", value: spawn)
|
|
}
|
|
if let storageVersion = item.worldMetadata?.storageVersion {
|
|
detailValueRow(title: "Storage Version", value: storageVersion)
|
|
}
|
|
if let networkVersion = item.worldMetadata?.networkVersion {
|
|
detailValueRow(title: "Network Version", value: networkVersion)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.frame(maxWidth: detailContentMaxWidth, alignment: .leading)
|
|
.padding(.horizontal, 28)
|
|
.padding(.top, 28)
|
|
.padding(.bottom, 24)
|
|
.frame(maxWidth: .infinity, alignment: .center)
|
|
}
|
|
}
|
|
.frame(maxWidth: .infinity, maxHeight: .infinity)
|
|
.task(id: item.id) {
|
|
storageBreakdown = await loadStorageBreakdown(for: item)
|
|
}
|
|
}
|
|
|
|
private var heroSection: some View {
|
|
RecordHeroView(
|
|
item: item,
|
|
metadataChips: heroMetadata,
|
|
fallbackSystemImage: fallbackIconName,
|
|
copyAction: {
|
|
copyToPasteboard(item.displayName)
|
|
},
|
|
actionRow: AnyView(actionRow),
|
|
contentMaxWidth: heroContentMaxWidth
|
|
)
|
|
}
|
|
|
|
private var actionRow: some View {
|
|
ViewThatFits(in: .horizontal) {
|
|
HStack(spacing: 10) {
|
|
actionButtons
|
|
}
|
|
|
|
VStack(alignment: .leading, spacing: 10) {
|
|
actionButtons
|
|
}
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
|
|
private var summaryGrid: some View {
|
|
VStack(alignment: .leading, spacing: 14) {
|
|
detailRow(title: "Name", value: item.displayName)
|
|
detailValueRow(title: "Size", value: sizeText)
|
|
detailValueRow(title: item.displayDateLabel, value: displayDateText)
|
|
detailValueRow(title: "Created", value: createdDateText)
|
|
|
|
if let gameMode = item.worldMetadata?.gameMode {
|
|
detailValueRow(title: "Game Mode", value: gameMode)
|
|
}
|
|
|
|
if let difficulty = item.worldMetadata?.difficulty {
|
|
detailValueRow(title: "Difficulty", value: difficulty)
|
|
}
|
|
|
|
if let seed = item.worldMetadata?.seed {
|
|
detailValueRow(title: "Seed", value: seed)
|
|
}
|
|
|
|
if let lastOpenedWithVersion = item.worldMetadata?.lastOpenedWithVersion {
|
|
detailValueRow(title: "Last Opened With", value: lastOpenedWithVersion)
|
|
}
|
|
|
|
if let inventoryVersion = item.worldMetadata?.inventoryVersion {
|
|
detailValueRow(title: "Inventory Version", value: inventoryVersion)
|
|
}
|
|
|
|
if item.contentType == .world {
|
|
detailValueRow(
|
|
title: "Pack References",
|
|
value: "\(behaviorPacks.count + resourcePacks.count)"
|
|
)
|
|
}
|
|
|
|
if item.contentType == .behaviorPack || item.contentType == .resourcePack {
|
|
detailValueRow(title: "UUID", value: item.packUUID ?? "Unavailable")
|
|
detailValueRow(title: "Version", value: item.packVersion ?? "Unavailable")
|
|
if let minimumEngineVersion = item.packMetadataDetails?.minimumEngineVersion {
|
|
detailValueRow(title: "Minimum Engine", value: minimumEngineVersion)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private var worldSettingsRows: [(title: String, value: String)] {
|
|
guard let metadata = item.worldMetadata else {
|
|
return []
|
|
}
|
|
|
|
return [
|
|
booleanRow("Cheats Enabled", metadata.cheatsEnabled),
|
|
booleanRow("Commands Enabled", metadata.commandsEnabled),
|
|
booleanRow("Education Features", metadata.educationFeaturesEnabled),
|
|
booleanRow("Coordinates Shown", metadata.coordinatesShown),
|
|
booleanRow("Keep Inventory", metadata.keepInventory),
|
|
booleanRow("Mob Griefing", metadata.mobGriefingEnabled),
|
|
booleanRow("Daylight Cycle", metadata.daylightCycleEnabled),
|
|
booleanRow("Weather Cycle", metadata.weatherCycleEnabled)
|
|
].compactMap { $0 }
|
|
}
|
|
|
|
private var healthMessages: [String]? {
|
|
var messages: [String] = []
|
|
|
|
if isSuspiciousPack {
|
|
messages.append("Manifest UUID is missing or unreadable for this pack, so matching is using a weaker fallback identity.")
|
|
}
|
|
|
|
if let unresolvedCount, unresolvedCount > 0 {
|
|
messages.append("\(unresolvedCount) referenced pack\(unresolvedCount == 1 ? "" : "s") could not be matched in this library.")
|
|
}
|
|
|
|
return messages.isEmpty ? nil : messages
|
|
}
|
|
|
|
private var relationshipHighlights: [String] {
|
|
guard item.contentType == .world else {
|
|
return []
|
|
}
|
|
|
|
var highlights: [String] = []
|
|
let totalPackCount = behaviorPacks.count + resourcePacks.count
|
|
if totalPackCount > 0 {
|
|
highlights.append("Uses \(totalPackCount) pack\(totalPackCount == 1 ? "" : "s")")
|
|
}
|
|
|
|
if let resolvedCount {
|
|
highlights.append("\(resolvedCount) found in this library")
|
|
}
|
|
|
|
if let unresolvedCount, unresolvedCount > 0 {
|
|
highlights.append("\(unresolvedCount) unresolved")
|
|
}
|
|
|
|
let relatedWorldCount = otherWorldsSharingReferencedPacks
|
|
if relatedWorldCount > 0 {
|
|
highlights.append("Shared by \(relatedWorldCount) other world\(relatedWorldCount == 1 ? "" : "s")")
|
|
}
|
|
|
|
return highlights
|
|
}
|
|
|
|
private var packUsageHighlights: [String] {
|
|
[
|
|
"\(worldsUsingPack.count) world\(worldsUsingPack.count == 1 ? "" : "s") use this",
|
|
backingPackInstances.count > 1 ? "\(backingPackInstances.count) copies indexed" : "1 indexed copy"
|
|
]
|
|
}
|
|
|
|
private var instanceHighlights: [String] {
|
|
let embeddedCount = backingPackInstances.filter {
|
|
$0.folderURL.pathComponents.contains(MinecraftContentType.world.collectionFolderName)
|
|
}.count
|
|
let topLevelCount = backingPackInstances.count - embeddedCount
|
|
|
|
var highlights: [String] = []
|
|
if topLevelCount > 0 {
|
|
highlights.append("\(topLevelCount) library cop\(topLevelCount == 1 ? "y" : "ies")")
|
|
}
|
|
if embeddedCount > 0 {
|
|
highlights.append("\(embeddedCount) embedded in worlds")
|
|
}
|
|
return highlights
|
|
}
|
|
|
|
private var storageHighlights: [String] {
|
|
var highlights = [storageFormatLabel]
|
|
if let approximateAgeText {
|
|
highlights.append(approximateAgeText)
|
|
}
|
|
return highlights
|
|
}
|
|
|
|
private var heroMetadata: [String] {
|
|
var chips = [item.contentType.rawValue, sizeText, "\(item.displayDateLabel) \(displayDateText)"]
|
|
|
|
if item.contentType == .world {
|
|
let packCount = behaviorPacks.count + resourcePacks.count
|
|
if packCount > 0 {
|
|
chips.append("\(packCount) pack\(packCount == 1 ? "" : "s")")
|
|
}
|
|
}
|
|
|
|
return chips
|
|
}
|
|
|
|
private var unresolvedCount: Int? {
|
|
source?.logicalWorld(forItemID: item.id)?.unresolvedReferences.count
|
|
}
|
|
|
|
private var resolvedCount: Int? {
|
|
guard let logicalWorld = source?.logicalWorld(forItemID: item.id) else {
|
|
return nil
|
|
}
|
|
|
|
return logicalWorld.usedPackIDs.count
|
|
}
|
|
|
|
private var otherWorldsSharingReferencedPacks: Int {
|
|
guard
|
|
let source,
|
|
let logicalWorld = source.logicalWorld(forItemID: item.id)
|
|
else {
|
|
return 0
|
|
}
|
|
|
|
let relatedWorldIDs = Set(logicalWorld.usedPackIDs.flatMap { packID in
|
|
source.worldsUsingPack(packID).map(\.id)
|
|
})
|
|
|
|
return max(0, relatedWorldIDs.subtracting([item.id]).count)
|
|
}
|
|
|
|
private var actionRowExportTitle: String {
|
|
if exportTitle != nil {
|
|
switch item.contentType {
|
|
case .world:
|
|
return "Export World"
|
|
case .behaviorPack, .resourcePack, .skinPack:
|
|
return "Export Pack"
|
|
case .worldTemplate:
|
|
return "Export Template"
|
|
}
|
|
}
|
|
|
|
return "Export"
|
|
}
|
|
|
|
private var fallbackIconName: String {
|
|
switch item.contentType {
|
|
case .world:
|
|
return "globe.europe.africa"
|
|
case .behaviorPack:
|
|
return "shippingbox"
|
|
case .resourcePack:
|
|
return "paintpalette"
|
|
case .skinPack:
|
|
return "person.crop.square"
|
|
case .worldTemplate:
|
|
return "doc.on.doc"
|
|
}
|
|
}
|
|
|
|
private var storageFormatLabel: String {
|
|
switch item.contentType {
|
|
case .world:
|
|
return FileManager.default.fileExists(atPath: item.folderURL.appendingPathComponent("db", isDirectory: true).path)
|
|
? "LevelDB world storage"
|
|
: "Flat-file world storage"
|
|
case .behaviorPack, .resourcePack, .skinPack, .worldTemplate:
|
|
return "Manifest-based package"
|
|
}
|
|
}
|
|
|
|
private var createdDateText: String {
|
|
(try? item.folderURL.resourceValues(forKeys: [.creationDateKey]).creationDate)?
|
|
.formatted(date: .abbreviated, time: .omitted) ?? "Unknown"
|
|
}
|
|
|
|
private var approximateAgeText: String? {
|
|
guard let createdDate = try? item.folderURL.resourceValues(forKeys: [.creationDateKey]).creationDate else {
|
|
return nil
|
|
}
|
|
|
|
let components = Calendar.current.dateComponents([.year, .month], from: createdDate, to: .now)
|
|
if let year = components.year, year > 0 {
|
|
return year == 1 ? "About 1 year old" : "About \(year) years old"
|
|
}
|
|
if let month = components.month, month > 0 {
|
|
return month == 1 ? "About 1 month old" : "About \(month) months old"
|
|
}
|
|
return "Recently created"
|
|
}
|
|
|
|
private var visibleContentsCountText: String {
|
|
if contents.isEmpty {
|
|
return "No visible files or folders"
|
|
}
|
|
|
|
return "\(contents.count)\(contents.count == directoryPreviewLimit ? "+" : "") visible entries"
|
|
}
|
|
|
|
private func recordSection<Content: View>(
|
|
title: String,
|
|
@ViewBuilder content: () -> Content
|
|
) -> some View {
|
|
VStack(alignment: .leading, spacing: 10) {
|
|
Text(title.uppercased())
|
|
.font(.caption.weight(.semibold))
|
|
.foregroundStyle(.secondary)
|
|
.tracking(0.5)
|
|
|
|
VStack(alignment: .leading, spacing: 14) {
|
|
content()
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.padding(18)
|
|
.background(.quaternary.opacity(0.32), in: RoundedRectangle(cornerRadius: 18, style: .continuous))
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func packSection(title: String, packs: [ContentPackReference]) -> some View {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text(title)
|
|
.font(.subheadline.weight(.semibold))
|
|
|
|
ForEach(packs) { pack in
|
|
recordListRow(
|
|
title: pack.name,
|
|
subtitle: packSecondaryText(pack),
|
|
iconURL: pack.iconURL,
|
|
fallbackSystemImage: pack.type == .resourcePack ? "paintpalette" : "shippingbox"
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func detailRow(title: String, value: String) -> some View {
|
|
VStack(alignment: .leading, spacing: 4) {
|
|
Text(title)
|
|
.font(.caption)
|
|
.foregroundStyle(.secondary)
|
|
|
|
Text(value)
|
|
.fixedSize(horizontal: false, vertical: true)
|
|
.textSelection(.enabled)
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func detailValueRow(title: String, value: String) -> some View {
|
|
HStack(alignment: .firstTextBaseline, spacing: 16) {
|
|
Text(title)
|
|
.foregroundStyle(.secondary)
|
|
Spacer()
|
|
Text(value)
|
|
.fontWeight(.medium)
|
|
.lineLimit(3)
|
|
.multilineTextAlignment(.trailing)
|
|
.textSelection(.enabled)
|
|
}
|
|
}
|
|
|
|
private func booleanRow(_ title: String, _ value: Bool?) -> (title: String, value: String)? {
|
|
guard let value else {
|
|
return nil
|
|
}
|
|
|
|
return (title, value ? "Yes" : "No")
|
|
}
|
|
|
|
private var sizeText: String {
|
|
if let sizeBytes = item.sizeBytes {
|
|
return ByteCountFormatter.string(fromByteCount: sizeBytes, countStyle: .file)
|
|
}
|
|
|
|
if item.sizeLoaded {
|
|
return "Unavailable"
|
|
}
|
|
|
|
return item.metadataLoaded ? "Calculating..." : "Loading..."
|
|
}
|
|
|
|
private var displayDateText: String {
|
|
item.displayDate.map { $0.formatted(date: .abbreviated, time: .omitted) } ?? "Unknown"
|
|
}
|
|
|
|
private func packSecondaryText(_ pack: ContentPackReference) -> String? {
|
|
let components = [pack.version.map { "v\($0)" }, pack.uuid]
|
|
.compactMap { $0 }
|
|
return components.isEmpty ? nil : components.joined(separator: " • ")
|
|
}
|
|
|
|
private func worldUsageSecondaryText(for world: MinecraftContentItem) -> String {
|
|
let dateText = world.displayDate?.formatted(date: .abbreviated, time: .omitted) ?? "Date unavailable"
|
|
return "\(world.displayDateLabel) \(dateText)"
|
|
}
|
|
|
|
private func packInstanceSecondaryText(for instance: MinecraftContentItem) -> String {
|
|
if instance.folderURL.pathComponents.contains(MinecraftContentType.world.collectionFolderName) {
|
|
return "Embedded in world copy"
|
|
}
|
|
|
|
return "Top-level pack folder"
|
|
}
|
|
|
|
private func summaryLines(_ values: [String]) -> some View {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
ForEach(values, id: \.self) { value in
|
|
Label(value, systemImage: "checkmark.circle")
|
|
.font(.subheadline)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private var actionButtons: some View {
|
|
ActionPillButton(
|
|
title: actionRowExportTitle,
|
|
systemImage: "arrow.down.circle.fill",
|
|
isDisabled: isPerformingItemAction || !areFileActionsEnabled,
|
|
prominence: .primary,
|
|
action: exportAction
|
|
)
|
|
|
|
ActionPillButton(
|
|
title: "Reveal",
|
|
systemImage: "folder.fill",
|
|
isDisabled: isPerformingItemAction || !areFileActionsEnabled,
|
|
prominence: .secondary,
|
|
action: revealAction
|
|
)
|
|
|
|
SharingPillButton(
|
|
title: "Share",
|
|
systemImage: "square.and.arrow.up",
|
|
isEnabled: !isPerformingItemAction && areFileActionsEnabled,
|
|
action: shareAction
|
|
)
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func recordListRow(
|
|
title: String,
|
|
subtitle: String?,
|
|
iconURL: URL?,
|
|
fallbackSystemImage: String
|
|
) -> some View {
|
|
HStack(alignment: .top, spacing: 12) {
|
|
PackReferenceIconView(iconURL: iconURL, fallbackSystemImage: fallbackSystemImage)
|
|
|
|
VStack(alignment: .leading, spacing: 2) {
|
|
Text(title)
|
|
.lineLimit(2)
|
|
|
|
if let subtitle, !subtitle.isEmpty {
|
|
Text(subtitle)
|
|
.font(.caption)
|
|
.foregroundStyle(.secondary)
|
|
.lineLimit(3)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private func loadStorageBreakdown(for item: MinecraftContentItem) async -> StorageBreakdown {
|
|
await Task.detached(priority: .utility) {
|
|
StorageBreakdown.build(for: item)
|
|
}.value
|
|
}
|
|
}
|
|
|
|
#if DEBUG
|
|
struct ItemDetailColumnViews_Previews: PreviewProvider {
|
|
static var previews: some View {
|
|
ItemDetailColumnPreviewContainer()
|
|
}
|
|
}
|
|
#endif
|