chore: import upstream snapshot with attribution
This commit is contained in:
wehub-resource-sync
@@ -0,0 +1,909 @@
|
||||
import Charts
|
||||
import CodexBarCore
|
||||
import SwiftUI
|
||||
|
||||
@MainActor
|
||||
struct CostHistoryChartMenuView: View {
|
||||
typealias DailyEntry = CostUsageDailyReport.Entry
|
||||
|
||||
enum AxisLabelPlacement: Equatable {
|
||||
case hidden
|
||||
case centered
|
||||
case edges
|
||||
}
|
||||
|
||||
private struct Point: Identifiable {
|
||||
let id: String
|
||||
let date: Date
|
||||
let costUSD: Double
|
||||
let totalTokens: Int?
|
||||
let requestCount: Int?
|
||||
|
||||
init(date: Date, costUSD: Double, totalTokens: Int?, requestCount: Int?) {
|
||||
self.date = date
|
||||
self.costUSD = costUSD
|
||||
self.totalTokens = totalTokens
|
||||
self.requestCount = requestCount
|
||||
self.id = "\(Int(date.timeIntervalSince1970))-\(costUSD)"
|
||||
}
|
||||
}
|
||||
|
||||
private struct DetailRow: Identifiable {
|
||||
let id: String
|
||||
let title: String
|
||||
let subtitle: String?
|
||||
let modeSubtitle: String?
|
||||
let accentColor: Color
|
||||
}
|
||||
|
||||
private struct DetailContent {
|
||||
let primary: String
|
||||
let rows: [DetailRow]
|
||||
}
|
||||
|
||||
private let provider: UsageProvider
|
||||
private let daily: [DailyEntry]
|
||||
private let totalCostUSD: Double?
|
||||
private let currencyCode: String
|
||||
private let historyDays: Int
|
||||
private let windowLabel: String?
|
||||
private let projects: [CostUsageProjectBreakdown]
|
||||
private let width: CGFloat
|
||||
@State private var selectedDateKey: String?
|
||||
|
||||
init(
|
||||
provider: UsageProvider,
|
||||
daily: [DailyEntry],
|
||||
totalCostUSD: Double?,
|
||||
currencyCode: String = "USD",
|
||||
historyDays: Int = 30,
|
||||
windowLabel: String? = nil,
|
||||
projects: [CostUsageProjectBreakdown] = [],
|
||||
width: CGFloat)
|
||||
{
|
||||
self.provider = provider
|
||||
self.daily = daily
|
||||
self.totalCostUSD = totalCostUSD
|
||||
self.currencyCode = currencyCode
|
||||
self.historyDays = max(1, min(365, historyDays))
|
||||
self.windowLabel = windowLabel
|
||||
self.projects = projects
|
||||
self.width = width
|
||||
}
|
||||
|
||||
var body: some View {
|
||||
let model = Self.makeModel(provider: self.provider, daily: self.daily)
|
||||
let selectedDateKey = self.selectedDateKey ?? Self.defaultSelectedDateKey(model: model)
|
||||
VStack(alignment: .leading, spacing: Self.outerSpacing) {
|
||||
if model.points.isEmpty {
|
||||
Text(L("No cost history data."))
|
||||
.font(.footnote)
|
||||
.foregroundStyle(.secondary)
|
||||
.accessibilityLabel(L("No cost history data."))
|
||||
} else {
|
||||
Chart {
|
||||
ForEach(model.points) { point in
|
||||
BarMark(
|
||||
x: .value(L("Day"), point.date, unit: .day),
|
||||
y: .value(L("Cost"), point.costUSD))
|
||||
.foregroundStyle(model.barColor)
|
||||
}
|
||||
if let peak = Self.peakPoint(model: model) {
|
||||
let capStart = max(peak.costUSD - Self.capHeight(maxValue: model.maxCostUSD), 0)
|
||||
BarMark(
|
||||
x: .value(L("Day"), peak.date, unit: .day),
|
||||
yStart: .value(L("Cap start"), capStart),
|
||||
yEnd: .value(L("Cap end"), peak.costUSD))
|
||||
.foregroundStyle(Color(nsColor: .systemYellow))
|
||||
}
|
||||
}
|
||||
.chartYAxis {
|
||||
AxisMarks(position: .leading, values: Self.yAxisTickValues(maxCostUSD: model.maxCostUSD)) { value in
|
||||
AxisGridLine().foregroundStyle(Color.clear)
|
||||
AxisTick().foregroundStyle(Color.clear)
|
||||
AxisValueLabel(centered: false) {
|
||||
if let raw = value.as(Double.self) {
|
||||
Text(Self.yAxisCostString(raw, currencyCode: self.currencyCode))
|
||||
.font(.caption2)
|
||||
.foregroundStyle(Color(nsColor: .tertiaryLabelColor))
|
||||
.padding(.leading, 4)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
.chartXAxis {
|
||||
AxisMarks(values: model.axisDates) { value in
|
||||
AxisGridLine().foregroundStyle(Color.clear)
|
||||
AxisTick().foregroundStyle(Color.clear)
|
||||
if let date = value.as(Date.self) {
|
||||
AxisValueLabel(anchor: Self.xAxisLabelAnchor(for: date, axisDates: model.axisDates)) {
|
||||
Text(date, format: .dateTime.month(.abbreviated).day())
|
||||
.font(.caption2)
|
||||
.foregroundStyle(Color(nsColor: .tertiaryLabelColor))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
.chartLegend(.hidden)
|
||||
.frame(height: Self.chartHeight)
|
||||
.accessibilityLabel(L("Cost history chart"))
|
||||
.accessibilityValue(
|
||||
model.points.isEmpty
|
||||
? L("No data")
|
||||
: String(format: L("%d days of cost data"), model.points.count))
|
||||
.chartOverlay { proxy in
|
||||
GeometryReader { geo in
|
||||
ZStack(alignment: .topLeading) {
|
||||
if let rect = self.selectionBandRect(model: model, proxy: proxy, geo: geo) {
|
||||
Rectangle()
|
||||
.fill(Self.selectionBandColor)
|
||||
.frame(width: rect.width, height: rect.height)
|
||||
.position(x: rect.midX, y: rect.midY)
|
||||
.allowsHitTesting(false)
|
||||
}
|
||||
MouseLocationReader { location in
|
||||
self.updateSelection(location: location, model: model, proxy: proxy, geo: geo)
|
||||
}
|
||||
.frame(maxWidth: .infinity, maxHeight: .infinity)
|
||||
.contentShape(Rectangle())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let detail = self.detailContent(selectedDateKey: selectedDateKey, model: model)
|
||||
VStack(alignment: .leading, spacing: Self.detailSpacing) {
|
||||
Text(detail.primary)
|
||||
.font(.caption)
|
||||
.foregroundStyle(.secondary)
|
||||
.lineLimit(1)
|
||||
.truncationMode(.tail)
|
||||
.frame(height: Self.detailPrimaryLineHeight, alignment: .leading)
|
||||
if model.detailViewportRowCount > 0 {
|
||||
ScrollView(.vertical) {
|
||||
VStack(alignment: .leading, spacing: Self.detailSpacing) {
|
||||
ForEach(detail.rows) { row in
|
||||
HStack(alignment: .top, spacing: 8) {
|
||||
Rectangle()
|
||||
.fill(row.accentColor)
|
||||
.frame(
|
||||
width: 2,
|
||||
height: Self.accentHeight(
|
||||
for: row,
|
||||
rowHeight: model.detailRowHeight))
|
||||
.padding(.top, 1)
|
||||
|
||||
VStack(alignment: .leading, spacing: 1) {
|
||||
Text(row.title)
|
||||
.font(.caption)
|
||||
.foregroundStyle(.secondary)
|
||||
.lineLimit(1)
|
||||
.truncationMode(.tail)
|
||||
.frame(height: Self.detailTitleLineHeight, alignment: .leading)
|
||||
if let subtitle = row.subtitle {
|
||||
Text(subtitle)
|
||||
.font(.caption2)
|
||||
.foregroundStyle(Color(nsColor: .tertiaryLabelColor))
|
||||
.lineLimit(1)
|
||||
.truncationMode(.tail)
|
||||
.frame(
|
||||
height: Self.detailSubtitleLineHeight,
|
||||
alignment: .leading)
|
||||
}
|
||||
if let modeSubtitle = row.modeSubtitle {
|
||||
Text(modeSubtitle)
|
||||
.font(.caption2)
|
||||
.foregroundStyle(Color(nsColor: .tertiaryLabelColor))
|
||||
.lineLimit(1)
|
||||
.truncationMode(.tail)
|
||||
.frame(
|
||||
height: Self.detailSubtitleLineHeight,
|
||||
alignment: .leading)
|
||||
}
|
||||
}
|
||||
}
|
||||
.frame(height: model.detailRowHeight, alignment: .leading)
|
||||
}
|
||||
}
|
||||
}
|
||||
.scrollIndicators(
|
||||
Self.detailRowsNeedScrolling(itemCount: detail.rows.count) ? .visible : .hidden)
|
||||
.frame(
|
||||
height: Self.detailRowsViewportHeight(
|
||||
rowCount: model.detailViewportRowCount,
|
||||
rowHeight: model.detailRowHeight),
|
||||
alignment: .topLeading)
|
||||
.id(selectedDateKey)
|
||||
|
||||
if model.hasDetailOverflow {
|
||||
Text(Self.detailOverflowHint(itemCount: detail.rows.count) ?? " ")
|
||||
.font(.caption2)
|
||||
.foregroundStyle(Color(nsColor: .tertiaryLabelColor))
|
||||
.frame(height: Self.detailHintHeight, alignment: .leading)
|
||||
.accessibilityHidden(!Self.detailRowsNeedScrolling(itemCount: detail.rows.count))
|
||||
}
|
||||
}
|
||||
}
|
||||
.frame(
|
||||
height: Self.detailBlockHeight(
|
||||
rowCount: model.detailViewportRowCount,
|
||||
hasOverflow: model.hasDetailOverflow,
|
||||
rowHeight: model.detailRowHeight),
|
||||
alignment: .topLeading)
|
||||
}
|
||||
|
||||
if let total = self.totalCostUSD {
|
||||
Text(String(
|
||||
format: L("Est. total (%@): %@"),
|
||||
self.windowLabel ?? Self.windowLabel(days: self.historyDays),
|
||||
self.costString(total)))
|
||||
.font(.caption)
|
||||
.foregroundStyle(.secondary)
|
||||
.lineLimit(1)
|
||||
.truncationMode(.head)
|
||||
.frame(height: Self.detailPrimaryLineHeight, alignment: .leading)
|
||||
}
|
||||
|
||||
if !self.projects.isEmpty {
|
||||
VStack(alignment: .leading, spacing: Self.projectRowSpacing) {
|
||||
Text("Projects")
|
||||
.font(.caption)
|
||||
.foregroundStyle(.secondary)
|
||||
.lineLimit(1)
|
||||
.frame(height: Self.detailPrimaryLineHeight, alignment: .leading)
|
||||
ForEach(Array(self.projects.prefix(Self.maxVisibleProjectRows)), id: \.projectRowID) { project in
|
||||
let visibleSources = Self.visibleProjectSources(project)
|
||||
VStack(alignment: .leading, spacing: Self.projectSourceSpacing) {
|
||||
self.projectParentRow(project)
|
||||
if !visibleSources.isEmpty {
|
||||
ForEach(
|
||||
Array(visibleSources.prefix(Self.maxVisibleProjectSourceRows)),
|
||||
id: \.sourceRowID)
|
||||
{ source in
|
||||
self.projectSourceRow(source)
|
||||
}
|
||||
let hiddenSourceCount = visibleSources.count - Self.maxVisibleProjectSourceRows
|
||||
if hiddenSourceCount > 0 {
|
||||
Text("+ \(hiddenSourceCount) more")
|
||||
.font(.caption2)
|
||||
.foregroundStyle(Color(nsColor: .tertiaryLabelColor))
|
||||
.lineLimit(1)
|
||||
.padding(.leading, Self.projectSourceIndent)
|
||||
.frame(height: Self.projectMoreRowHeight, alignment: .leading)
|
||||
}
|
||||
}
|
||||
}
|
||||
.frame(height: Self.projectEntryHeight(project), alignment: .topLeading)
|
||||
}
|
||||
}
|
||||
.frame(height: Self.projectBlockHeight(projects: self.projects), alignment: .topLeading)
|
||||
}
|
||||
}
|
||||
.padding(.horizontal, 16)
|
||||
.padding(.vertical, Self.verticalPadding)
|
||||
.frame(minWidth: self.width, maxWidth: .infinity, alignment: .top)
|
||||
}
|
||||
|
||||
private struct Model {
|
||||
let points: [Point]
|
||||
let pointsByDateKey: [String: Point]
|
||||
let entriesByDateKey: [String: DailyEntry]
|
||||
let dateKeys: [(key: String, date: Date)]
|
||||
let axisDates: [Date]
|
||||
let barColor: Color
|
||||
let peakKey: String?
|
||||
let maxCostUSD: Double
|
||||
let detailViewportRowCount: Int
|
||||
let hasDetailOverflow: Bool
|
||||
let detailRowHeight: CGFloat
|
||||
}
|
||||
|
||||
private static let selectionBandColor = Color(nsColor: .labelColor).opacity(0.1)
|
||||
static let maxVisibleDetailLines = 4
|
||||
private static let detailPrimaryLineHeight: CGFloat = 16
|
||||
private static let detailTitleLineHeight: CGFloat = 16
|
||||
private static let detailSubtitleLineHeight: CGFloat = 13
|
||||
private static let compactDetailRowHeight: CGFloat = 36
|
||||
private static let expandedDetailRowHeight: CGFloat = 44
|
||||
private static let detailSpacing: CGFloat = 6
|
||||
private static let detailHintHeight: CGFloat = 13
|
||||
private static let chartHeight: CGFloat = 130
|
||||
private static let outerSpacing: CGFloat = 10
|
||||
private static let projectRowHeight: CGFloat = 31
|
||||
private static let projectRowSpacing: CGFloat = 5
|
||||
private static let maxVisibleProjectRows = 5
|
||||
private static let projectSourceRowHeight: CGFloat = 29
|
||||
private static let projectSourceSpacing: CGFloat = 3
|
||||
private static let projectSourceIndent: CGFloat = 10
|
||||
private static let projectMoreRowHeight: CGFloat = 16
|
||||
private static let maxVisibleProjectSourceRows = 2
|
||||
static let verticalPadding: CGFloat = 10
|
||||
|
||||
static func windowLabel(days: Int) -> String {
|
||||
if days == 1 {
|
||||
return L("Today")
|
||||
}
|
||||
return String(format: L("Last %d days"), days)
|
||||
}
|
||||
|
||||
private static func accentHeight(for row: DetailRow, rowHeight: CGFloat) -> CGFloat {
|
||||
row.subtitle == nil && row.modeSubtitle == nil ? 14 : rowHeight
|
||||
}
|
||||
|
||||
private static func capHeight(maxValue: Double) -> Double {
|
||||
maxValue * 0.05
|
||||
}
|
||||
|
||||
/// Y-axis tick values for the cost chart: 0, mid, max when the range is at
|
||||
/// $1 or more; 0 and max for smaller ranges; empty for flat/no data so the
|
||||
/// axis renders no labels.
|
||||
private static func yAxisTickValues(maxCostUSD: Double) -> [Double] {
|
||||
guard maxCostUSD > 0 else { return [] }
|
||||
if maxCostUSD < 1.0 {
|
||||
return [0, maxCostUSD]
|
||||
}
|
||||
return [0, maxCostUSD / 2, maxCostUSD]
|
||||
}
|
||||
|
||||
private static func makeModel(provider: UsageProvider, daily: [DailyEntry]) -> Model {
|
||||
let sorted = daily.sorted { lhs, rhs in lhs.date < rhs.date }
|
||||
var points: [Point] = []
|
||||
points.reserveCapacity(sorted.count)
|
||||
|
||||
var pointsByKey: [String: Point] = [:]
|
||||
pointsByKey.reserveCapacity(sorted.count)
|
||||
|
||||
var entriesByKey: [String: DailyEntry] = [:]
|
||||
entriesByKey.reserveCapacity(sorted.count)
|
||||
|
||||
var dateKeys: [(key: String, date: Date)] = []
|
||||
dateKeys.reserveCapacity(sorted.count)
|
||||
|
||||
var peak: (key: String, costUSD: Double)?
|
||||
var maxCostUSD: Double = 0
|
||||
var maxDetailRows = 0
|
||||
var hasModeDetails = false
|
||||
for entry in sorted {
|
||||
guard let (costUSD, date) = self.chartPointInput(for: entry) else { continue }
|
||||
let point = Point(
|
||||
date: date,
|
||||
costUSD: costUSD,
|
||||
totalTokens: entry.totalTokens,
|
||||
requestCount: entry.requestCount)
|
||||
points.append(point)
|
||||
pointsByKey[entry.date] = point
|
||||
entriesByKey[entry.date] = entry
|
||||
dateKeys.append((entry.date, date))
|
||||
let modelBreakdowns = entry.modelBreakdowns ?? []
|
||||
maxDetailRows = max(maxDetailRows, modelBreakdowns.count)
|
||||
hasModeDetails = hasModeDetails || modelBreakdowns.contains { Self.hasModeSubtitle($0) }
|
||||
if let cur = peak {
|
||||
if costUSD > cur.costUSD {
|
||||
peak = (entry.date, costUSD)
|
||||
}
|
||||
} else {
|
||||
peak = (entry.date, costUSD)
|
||||
}
|
||||
maxCostUSD = max(maxCostUSD, costUSD)
|
||||
}
|
||||
|
||||
let axisDates: [Date] = {
|
||||
guard let first = dateKeys.first?.date, let last = dateKeys.last?.date else { return [] }
|
||||
if Calendar.current.isDate(first, inSameDayAs: last) {
|
||||
return [first]
|
||||
}
|
||||
return [first, last]
|
||||
}()
|
||||
|
||||
let barColor = Self.barColor(for: provider)
|
||||
return Model(
|
||||
points: points,
|
||||
pointsByDateKey: pointsByKey,
|
||||
entriesByDateKey: entriesByKey,
|
||||
dateKeys: dateKeys,
|
||||
axisDates: axisDates,
|
||||
barColor: barColor,
|
||||
peakKey: maxCostUSD > 0 ? peak?.key : nil,
|
||||
maxCostUSD: maxCostUSD,
|
||||
detailViewportRowCount: min(maxDetailRows, self.maxVisibleDetailLines),
|
||||
hasDetailOverflow: maxDetailRows > self.maxVisibleDetailLines,
|
||||
detailRowHeight: hasModeDetails ? self.expandedDetailRowHeight : self.compactDetailRowHeight)
|
||||
}
|
||||
|
||||
private static func axisLabelPlacement(for dates: [Date]) -> AxisLabelPlacement {
|
||||
switch dates.count {
|
||||
case 0: .hidden
|
||||
case 1: .centered
|
||||
default: .edges
|
||||
}
|
||||
}
|
||||
|
||||
private static func xAxisLabelAnchor(for date: Date, axisDates: [Date]) -> UnitPoint {
|
||||
switch self.axisLabelPlacement(for: axisDates) {
|
||||
case .hidden, .centered:
|
||||
.top
|
||||
case .edges:
|
||||
if let first = axisDates.first, Calendar.current.isDate(date, inSameDayAs: first) {
|
||||
.topLeading
|
||||
} else if let last = axisDates.last, Calendar.current.isDate(date, inSameDayAs: last) {
|
||||
.topTrailing
|
||||
} else {
|
||||
.top
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static func barColor(for provider: UsageProvider) -> Color {
|
||||
let color = ProviderDescriptorRegistry.descriptor(for: provider).branding.color
|
||||
return Color(red: color.red, green: color.green, blue: color.blue)
|
||||
}
|
||||
|
||||
private static func dateFromDayKey(_ key: String) -> Date? {
|
||||
let parts = key.split(separator: "-")
|
||||
guard parts.count == 3,
|
||||
let year = Int(parts[0]),
|
||||
let month = Int(parts[1]),
|
||||
let day = Int(parts[2]) else { return nil }
|
||||
|
||||
var comps = DateComponents()
|
||||
comps.calendar = Calendar.current
|
||||
comps.timeZone = TimeZone.current
|
||||
comps.year = year
|
||||
comps.month = month
|
||||
comps.day = day
|
||||
comps.hour = 12
|
||||
return comps.date
|
||||
}
|
||||
|
||||
private static func chartPointInput(for entry: DailyEntry) -> (costUSD: Double, date: Date)? {
|
||||
guard let costUSD = entry.costUSD, costUSD >= 0 else { return nil }
|
||||
guard let date = self.dateFromDayKey(entry.date) else { return nil }
|
||||
return (costUSD, date)
|
||||
}
|
||||
|
||||
private static func peakPoint(model: Model) -> Point? {
|
||||
guard let key = model.peakKey else { return nil }
|
||||
return model.pointsByDateKey[key]
|
||||
}
|
||||
|
||||
private static func hasModeSubtitle(_ item: CostUsageDailyReport.ModelBreakdown) -> Bool {
|
||||
item.standardCostUSD != nil || item.priorityCostUSD != nil
|
||||
}
|
||||
|
||||
private static func detailRowsViewportHeight(rowCount: Int, rowHeight: CGFloat) -> CGFloat {
|
||||
guard rowCount > 0 else { return 0 }
|
||||
return CGFloat(rowCount) * rowHeight + CGFloat(rowCount - 1) * self.detailSpacing
|
||||
}
|
||||
|
||||
private static func detailBlockHeight(rowCount: Int, hasOverflow: Bool, rowHeight: CGFloat) -> CGFloat {
|
||||
guard rowCount > 0 else { return self.detailPrimaryLineHeight }
|
||||
var height = self.detailPrimaryLineHeight + self.detailSpacing
|
||||
height += self.detailRowsViewportHeight(rowCount: rowCount, rowHeight: rowHeight)
|
||||
if hasOverflow {
|
||||
height += self.detailSpacing + self.detailHintHeight
|
||||
}
|
||||
return height
|
||||
}
|
||||
|
||||
private static func projectBlockHeight(projects: [CostUsageProjectBreakdown]) -> CGFloat {
|
||||
let visibleProjects = Array(projects.prefix(self.maxVisibleProjectRows))
|
||||
guard !visibleProjects.isEmpty else { return 0 }
|
||||
return self.detailPrimaryLineHeight
|
||||
+ self.projectRowSpacing
|
||||
+ visibleProjects.reduce(CGFloat(0)) { $0 + self.projectEntryHeight($1) }
|
||||
+ CGFloat(max(visibleProjects.count - 1, 0)) * self.projectRowSpacing
|
||||
}
|
||||
|
||||
private static func projectEntryHeight(_ project: CostUsageProjectBreakdown) -> CGFloat {
|
||||
let sources = self.visibleProjectSources(project)
|
||||
guard !sources.isEmpty else { return self.projectRowHeight }
|
||||
let visibleSources = min(sources.count, self.maxVisibleProjectSourceRows)
|
||||
let moreRows = sources.count > self.maxVisibleProjectSourceRows ? 1 : 0
|
||||
return self.projectRowHeight
|
||||
+ CGFloat(visibleSources) * (self.projectSourceRowHeight + self.projectSourceSpacing)
|
||||
+ CGFloat(moreRows) * (self.projectMoreRowHeight + self.projectSourceSpacing)
|
||||
}
|
||||
|
||||
static func visibleProjectSources(
|
||||
_ project: CostUsageProjectBreakdown) -> [CostUsageProjectSourceBreakdown]
|
||||
{
|
||||
guard project.sources.count == 1 else { return project.sources }
|
||||
guard let source = project.sources.first, source.path != project.path else { return [] }
|
||||
return [source]
|
||||
}
|
||||
|
||||
private static func defaultSelectedDateKey(model: Model) -> String? {
|
||||
model.dateKeys.last?.key
|
||||
}
|
||||
|
||||
private func selectionBandRect(model: Model, proxy: ChartProxy, geo: GeometryProxy) -> CGRect? {
|
||||
guard let key = self.selectedDateKey else { return nil }
|
||||
guard let plotAnchor = proxy.plotFrame else { return nil }
|
||||
let plotFrame = geo[plotAnchor]
|
||||
guard let index = model.dateKeys.firstIndex(where: { $0.key == key }) else { return nil }
|
||||
let date = model.dateKeys[index].date
|
||||
guard let x = proxy.position(forX: date) else { return nil }
|
||||
|
||||
// Use the calendar day slot width so the band stays the same size regardless of data gaps.
|
||||
let nextDayX = proxy.position(forX: ChartBarHoverSelection.nextCalendarDay(after: date)) ?? (x + 20)
|
||||
let slotWidth = abs(nextDayX - x)
|
||||
let barHalfWidth = slotWidth * 0.25 + 2
|
||||
|
||||
let left = plotFrame.origin.x + x - barHalfWidth
|
||||
let right = plotFrame.origin.x + x + barHalfWidth
|
||||
return CGRect(x: left, y: plotFrame.origin.y, width: right - left, height: plotFrame.height)
|
||||
}
|
||||
|
||||
private func updateSelection(
|
||||
location: CGPoint?,
|
||||
model: Model,
|
||||
proxy: ChartProxy,
|
||||
geo: GeometryProxy)
|
||||
{
|
||||
// Keep the last hovered day selected when the pointer leaves the chart so the adjacent
|
||||
// model-breakdown scroller remains interactive. The selection resets with the menu view.
|
||||
guard let location else { return }
|
||||
|
||||
guard let plotAnchor = proxy.plotFrame else { return }
|
||||
let plotFrame = geo[plotAnchor]
|
||||
guard plotFrame.contains(location) else { return }
|
||||
|
||||
let xInPlot = location.x - plotFrame.origin.x
|
||||
guard let date: Date = proxy.value(atX: xInPlot) else { return }
|
||||
guard let nearest = self.nearestDateKey(to: date, model: model) else { return }
|
||||
|
||||
// Stay on the last selected bar when cursor is in the gap between bars.
|
||||
if let nearestEntry = model.dateKeys.first(where: { $0.key == nearest }),
|
||||
let barX = proxy.position(forX: nearestEntry.date)
|
||||
{
|
||||
let nextDayX = proxy.position(forX: ChartBarHoverSelection.nextCalendarDay(after: nearestEntry.date)) ??
|
||||
(barX + 20)
|
||||
let slotWidth = abs(nextDayX - barX)
|
||||
guard ChartBarHoverSelection.accepts(
|
||||
distanceFromBarCenter: abs(location.x - (plotFrame.origin.x + barX)),
|
||||
barHalfWidth: slotWidth * 0.25 + 2,
|
||||
selectableCount: model.dateKeys.count)
|
||||
else { return }
|
||||
}
|
||||
|
||||
if self.selectedDateKey != nearest {
|
||||
self.selectedDateKey = nearest
|
||||
}
|
||||
}
|
||||
|
||||
private func projectSummary(_ project: CostUsageProjectBreakdown) -> String {
|
||||
let cost = project.totalCostUSD
|
||||
.map { self.costString($0) } ?? "—"
|
||||
guard let totalTokens = project.totalTokens else { return cost }
|
||||
return "\(cost) · \(L("%@ tokens", UsageFormatter.tokenCountString(totalTokens)))"
|
||||
}
|
||||
|
||||
private func projectParentRow(_ project: CostUsageProjectBreakdown) -> some View {
|
||||
VStack(alignment: .leading, spacing: 1) {
|
||||
HStack(spacing: 8) {
|
||||
Text(project.name)
|
||||
.font(.caption)
|
||||
.foregroundStyle(.secondary)
|
||||
.lineLimit(1)
|
||||
.truncationMode(.tail)
|
||||
Spacer(minLength: 8)
|
||||
Text(self.projectSummary(project))
|
||||
.font(.caption2)
|
||||
.foregroundStyle(Color(nsColor: .tertiaryLabelColor))
|
||||
.lineLimit(1)
|
||||
.truncationMode(.head)
|
||||
}
|
||||
if let path = project.path {
|
||||
Text(path)
|
||||
.font(.caption2)
|
||||
.foregroundStyle(Color(nsColor: .tertiaryLabelColor))
|
||||
.lineLimit(1)
|
||||
.truncationMode(.middle)
|
||||
}
|
||||
}
|
||||
.frame(height: Self.projectRowHeight, alignment: .leading)
|
||||
}
|
||||
|
||||
private func projectSourceRow(_ source: CostUsageProjectSourceBreakdown) -> some View {
|
||||
VStack(alignment: .leading, spacing: 1) {
|
||||
HStack(spacing: 6) {
|
||||
Text(source.name)
|
||||
.font(.caption2)
|
||||
.foregroundStyle(Color(nsColor: .tertiaryLabelColor))
|
||||
.lineLimit(1)
|
||||
.truncationMode(.tail)
|
||||
Spacer(minLength: 6)
|
||||
Text(self.projectSourceSummary(source))
|
||||
.font(.caption2)
|
||||
.foregroundStyle(Color(nsColor: .tertiaryLabelColor))
|
||||
.lineLimit(1)
|
||||
.truncationMode(.head)
|
||||
}
|
||||
if let path = source.path {
|
||||
Text(path)
|
||||
.font(.caption2)
|
||||
.foregroundStyle(Color(nsColor: .quaternaryLabelColor))
|
||||
.lineLimit(1)
|
||||
.truncationMode(.middle)
|
||||
}
|
||||
}
|
||||
.padding(.leading, Self.projectSourceIndent)
|
||||
.frame(height: Self.projectSourceRowHeight, alignment: .leading)
|
||||
}
|
||||
|
||||
private func projectSourceSummary(_ source: CostUsageProjectSourceBreakdown) -> String {
|
||||
let cost = source.totalCostUSD
|
||||
.map { self.costString($0) } ?? "—"
|
||||
guard let totalTokens = source.totalTokens else { return cost }
|
||||
return "\(cost) · \(L("%@ tokens", UsageFormatter.tokenCountString(totalTokens)))"
|
||||
}
|
||||
|
||||
private func nearestDateKey(to date: Date, model: Model) -> String? {
|
||||
guard !model.dateKeys.isEmpty else { return nil }
|
||||
var best: (key: String, distance: TimeInterval)?
|
||||
for entry in model.dateKeys {
|
||||
let dist = abs(entry.date.timeIntervalSince(date))
|
||||
if let cur = best {
|
||||
if dist < cur.distance {
|
||||
best = (entry.key, dist)
|
||||
}
|
||||
} else {
|
||||
best = (entry.key, dist)
|
||||
}
|
||||
}
|
||||
return best?.key
|
||||
}
|
||||
|
||||
private func detailContent(selectedDateKey: String?, model: Model) -> DetailContent {
|
||||
guard let key = selectedDateKey,
|
||||
let point = model.pointsByDateKey[key],
|
||||
let date = Self.dateFromDayKey(key)
|
||||
else {
|
||||
return DetailContent(primary: L("Hover a bar for details"), rows: [])
|
||||
}
|
||||
|
||||
let dayLabel = date.formatted(.dateTime.month(.abbreviated).day())
|
||||
let cost = self.costString(point.costUSD)
|
||||
var parts = [cost]
|
||||
if let tokens = point.totalTokens {
|
||||
parts.append("\(UsageFormatter.tokenCountString(tokens)) tokens")
|
||||
}
|
||||
if let requests = point.requestCount {
|
||||
parts.append("\(UsageFormatter.tokenCountString(requests)) requests")
|
||||
}
|
||||
let primary = "\(dayLabel): \(parts.joined(separator: " · "))"
|
||||
return DetailContent(primary: primary, rows: self.breakdownRows(key: key, model: model))
|
||||
}
|
||||
|
||||
private func breakdownRows(key: String, model: Model) -> [DetailRow] {
|
||||
guard let entry = model.entriesByDateKey[key] else { return [] }
|
||||
guard let breakdown = entry.modelBreakdowns, !breakdown.isEmpty else { return [] }
|
||||
|
||||
return Self.orderedBreakdownItems(breakdown)
|
||||
.enumerated()
|
||||
.map { index, item in
|
||||
DetailRow(
|
||||
id: "\(item.modelName)-\(index)",
|
||||
title: UsageFormatter.modelDisplayName(item.modelName),
|
||||
subtitle: self.modelBreakdownTotalSubtitle(item),
|
||||
modeSubtitle: self.modelBreakdownModeSubtitle(item),
|
||||
accentColor: model.barColor.opacity(Self.breakdownAccentOpacity(for: index)))
|
||||
}
|
||||
}
|
||||
|
||||
static func orderedBreakdownItems(
|
||||
_ breakdown: [CostUsageDailyReport.ModelBreakdown]) -> [CostUsageDailyReport.ModelBreakdown]
|
||||
{
|
||||
breakdown.sorted { lhs, rhs in
|
||||
let lCost = lhs.costUSD ?? -1
|
||||
let rCost = rhs.costUSD ?? -1
|
||||
if lCost != rCost {
|
||||
return lCost > rCost
|
||||
}
|
||||
|
||||
let lTokens = lhs.totalTokens ?? -1
|
||||
let rTokens = rhs.totalTokens ?? -1
|
||||
if lTokens != rTokens {
|
||||
return lTokens > rTokens
|
||||
}
|
||||
|
||||
return lhs.modelName > rhs.modelName
|
||||
}
|
||||
}
|
||||
|
||||
static func detailViewportRowCount(itemCount: Int) -> Int {
|
||||
min(max(itemCount, 0), self.maxVisibleDetailLines)
|
||||
}
|
||||
|
||||
static func detailRowsNeedScrolling(itemCount: Int) -> Bool {
|
||||
itemCount > self.maxVisibleDetailLines
|
||||
}
|
||||
|
||||
static func detailOverflowHint(itemCount: Int) -> String? {
|
||||
self.detailRowsNeedScrolling(itemCount: itemCount) ? L("Scroll to see more models") : nil
|
||||
}
|
||||
|
||||
private func modelBreakdownTotalSubtitle(_ item: CostUsageDailyReport.ModelBreakdown) -> String? {
|
||||
UsageFormatter.modelCostDetail(
|
||||
item.modelName,
|
||||
costUSD: item.costUSD,
|
||||
totalTokens: item.totalTokens,
|
||||
currencyCode: self.currencyCode)
|
||||
}
|
||||
|
||||
private func modelBreakdownModeSubtitle(_ item: CostUsageDailyReport.ModelBreakdown) -> String? {
|
||||
var parts: [String] = []
|
||||
if let standardCost = item.standardCostUSD {
|
||||
var standardPart = "Std \(self.costString(standardCost))"
|
||||
if let standardTokens = item.standardTokens {
|
||||
standardPart += " · \(UsageFormatter.tokenCountString(standardTokens))"
|
||||
}
|
||||
parts.append(standardPart)
|
||||
}
|
||||
if let priorityCost = item.priorityCostUSD {
|
||||
var priorityPart = "Fast \(self.costString(priorityCost))"
|
||||
if let priorityTokens = item.priorityTokens {
|
||||
priorityPart += " · \(UsageFormatter.tokenCountString(priorityTokens))"
|
||||
}
|
||||
parts.append(priorityPart)
|
||||
}
|
||||
guard !parts.isEmpty else { return nil }
|
||||
return parts.joined(separator: " / ")
|
||||
}
|
||||
|
||||
private func costString(_ value: Double) -> String {
|
||||
Self.costString(value, currencyCode: self.currencyCode)
|
||||
}
|
||||
|
||||
private static func costString(_ value: Double, currencyCode: String) -> String {
|
||||
UsageFormatter.currencyString(value, currencyCode: currencyCode)
|
||||
}
|
||||
|
||||
private static func yAxisCostString(_ value: Double, currencyCode: String) -> String {
|
||||
UsageFormatter.compactCurrencyString(value, currencyCode: currencyCode)
|
||||
}
|
||||
|
||||
private static func breakdownAccentOpacity(for index: Int) -> Double {
|
||||
let opacity = 0.75 - (Double(index) * 0.12)
|
||||
return max(0.3, opacity)
|
||||
}
|
||||
}
|
||||
|
||||
extension CostHistoryChartMenuView {
|
||||
struct RenderFingerprint: Equatable {
|
||||
let currencyCode: String
|
||||
let historyDays: Int
|
||||
let windowLabel: String?
|
||||
let totalCostBitPattern: UInt64?
|
||||
let hasDailyEntries: Bool
|
||||
let daily: [VisibleDailyFingerprint]
|
||||
let projects: [VisibleProjectFingerprint]
|
||||
}
|
||||
|
||||
struct VisibleDailyFingerprint: Equatable {
|
||||
let date: String
|
||||
let totalTokens: Int?
|
||||
let requestCount: Int?
|
||||
let costBitPattern: UInt64?
|
||||
let modelBreakdowns: [VisibleModelBreakdownFingerprint]
|
||||
}
|
||||
|
||||
struct VisibleModelBreakdownFingerprint: Equatable {
|
||||
let modelName: String
|
||||
let costBitPattern: UInt64?
|
||||
let totalTokens: Int?
|
||||
let standardCostBitPattern: UInt64?
|
||||
let priorityCostBitPattern: UInt64?
|
||||
let standardTokens: Int?
|
||||
let priorityTokens: Int?
|
||||
}
|
||||
|
||||
struct VisibleProjectFingerprint: Equatable {
|
||||
let name: String
|
||||
let path: String?
|
||||
let totalTokens: Int?
|
||||
let totalCostBitPattern: UInt64?
|
||||
let visibleSourceCount: Int
|
||||
let sources: [VisibleSourceFingerprint]
|
||||
}
|
||||
|
||||
struct VisibleSourceFingerprint: Equatable {
|
||||
let name: String
|
||||
let path: String?
|
||||
let totalTokens: Int?
|
||||
let totalCostBitPattern: UInt64?
|
||||
}
|
||||
|
||||
static func renderFingerprint(
|
||||
from snapshot: CostUsageTokenSnapshot,
|
||||
provider: UsageProvider) -> RenderFingerprint
|
||||
{
|
||||
let projects = provider == .codex ? snapshot.projects : []
|
||||
return RenderFingerprint(
|
||||
currencyCode: snapshot.currencyCode,
|
||||
historyDays: snapshot.historyDays,
|
||||
windowLabel: snapshot.historyLabel,
|
||||
totalCostBitPattern: snapshot.last30DaysCostUSD.map(\.bitPattern),
|
||||
hasDailyEntries: !snapshot.daily.isEmpty,
|
||||
daily: snapshot.daily
|
||||
.filter { self.chartPointInput(for: $0) != nil }
|
||||
.sorted { $0.date < $1.date }
|
||||
.map(self.visibleDailyFingerprint),
|
||||
projects: Array(projects.prefix(self.maxVisibleProjectRows)).map { project in
|
||||
let visibleSources = self.visibleProjectSources(project)
|
||||
return VisibleProjectFingerprint(
|
||||
name: project.name,
|
||||
path: project.path,
|
||||
totalTokens: project.totalTokens,
|
||||
totalCostBitPattern: project.totalCostUSD.map(\.bitPattern),
|
||||
visibleSourceCount: visibleSources.count,
|
||||
sources: Array(visibleSources.prefix(self.maxVisibleProjectSourceRows)).map { source in
|
||||
VisibleSourceFingerprint(
|
||||
name: source.name,
|
||||
path: source.path,
|
||||
totalTokens: source.totalTokens,
|
||||
totalCostBitPattern: source.totalCostUSD.map(\.bitPattern))
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
private static func visibleDailyFingerprint(_ entry: DailyEntry) -> VisibleDailyFingerprint {
|
||||
VisibleDailyFingerprint(
|
||||
date: entry.date,
|
||||
totalTokens: entry.totalTokens,
|
||||
requestCount: entry.requestCount,
|
||||
costBitPattern: entry.costUSD.map(\.bitPattern),
|
||||
modelBreakdowns: self.orderedBreakdownItems(entry.modelBreakdowns ?? []).map { item in
|
||||
VisibleModelBreakdownFingerprint(
|
||||
modelName: item.modelName,
|
||||
costBitPattern: item.costUSD.map(\.bitPattern),
|
||||
totalTokens: item.totalTokens,
|
||||
standardCostBitPattern: item.standardCostUSD.map(\.bitPattern),
|
||||
priorityCostBitPattern: item.priorityCostUSD.map(\.bitPattern),
|
||||
standardTokens: item.standardCostUSD == nil ? nil : item.standardTokens,
|
||||
priorityTokens: item.priorityCostUSD == nil ? nil : item.priorityTokens)
|
||||
})
|
||||
}
|
||||
|
||||
static func _defaultSelectedDateKeyForTesting(provider: UsageProvider, daily: [DailyEntry]) -> String? {
|
||||
self.defaultSelectedDateKey(model: self.makeModel(provider: provider, daily: daily))
|
||||
}
|
||||
|
||||
static func _axisDatesForTesting(provider: UsageProvider, daily: [DailyEntry]) -> [Date] {
|
||||
self.makeModel(provider: provider, daily: daily).axisDates
|
||||
}
|
||||
|
||||
static func _axisLabelPlacementForTesting(
|
||||
provider: UsageProvider,
|
||||
daily: [DailyEntry]) -> AxisLabelPlacement
|
||||
{
|
||||
self.axisLabelPlacement(for: self.makeModel(provider: provider, daily: daily).axisDates)
|
||||
}
|
||||
|
||||
static func _yAxisTickValuesForTesting(maxCostUSD: Double) -> [Double] {
|
||||
self.yAxisTickValues(maxCostUSD: maxCostUSD)
|
||||
}
|
||||
|
||||
static func _yAxisCostStringForTesting(_ value: Double, currencyCode: String = "USD") -> String {
|
||||
self.yAxisCostString(value, currencyCode: currencyCode)
|
||||
}
|
||||
|
||||
static func _detailViewportConfigurationForTesting(
|
||||
provider: UsageProvider,
|
||||
daily: [DailyEntry]) -> (rowCount: Int, hasOverflow: Bool, rowHeight: CGFloat)
|
||||
{
|
||||
let model = self.makeModel(provider: provider, daily: daily)
|
||||
return (model.detailViewportRowCount, model.hasDetailOverflow, model.detailRowHeight)
|
||||
}
|
||||
}
|
||||
|
||||
extension CostUsageProjectBreakdown {
|
||||
fileprivate var projectRowID: String {
|
||||
self.path ?? "unknown:\(self.name)"
|
||||
}
|
||||
}
|
||||
|
||||
extension CostUsageProjectSourceBreakdown {
|
||||
fileprivate var sourceRowID: String {
|
||||
self.path ?? "unknown:\(self.name)"
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user