Open History to see the last commit
1import { ProviderInstanceIcon } from "../chat/ProviderInstanceIcon";
2import type { UsageProviderKind } from "@t3tools/contracts";
3import { useLayoutEffect, useRef, useState } from "react";
4
5import type { DailyTotals, HourlyTotals } from "@t3tools/shared/usageMerge";
6import {
7 formatDayShort,
8 formatHourShort,
9 formatRelativeHourShort,
10 formatTokens,
11 formatUsd,
12} from "@t3tools/shared/usageFormat";
13import { cn } from "~/lib/utils";
14import { PROVIDER_ORDER, PROVIDER_PRESENTATION } from "./usageProviders";
15import { observeResize } from "~/lib/observeResize";
16
17const VIEW_WIDTH = 960;
18const VIEW_HEIGHT = 260;
19const TICK_COUNT = 4;
20const PLOT_TOP = 8;
21const NONE_LOADING: ReadonlySet<UsageProviderKind> = new Set();
22
23export type UsageChartMetric = "tokens" | "cost";
24
25interface UsageProviderChartProps {
26 readonly providers: readonly UsageProviderKind[];
27 readonly loadingProviders?: ReadonlySet<UsageProviderKind>;
28 readonly days: readonly string[];
29 readonly daily: readonly DailyTotals[];
30 readonly hours: readonly string[];
31 readonly hourly: readonly HourlyTotals[];
32 readonly metric: UsageChartMetric;
33 readonly referenceTime: string | undefined;
34 readonly resolution: "day" | "hour";
35 readonly timeZone: string;
36 readonly hour12: boolean;
37}
38
39export interface DayColumn {
40 readonly bands: readonly {
41 readonly provider: UsageProviderKind;
42 readonly value: number;
43 }[];
44 readonly total: number;
45}
46
47interface Point {
48 readonly x: number;
49 readonly y: number;
50}
51
52function valueFor(
53 totals: DailyTotals | HourlyTotals | undefined,
54 provider: UsageProviderKind,
55 metric: UsageChartMetric,
56): number {
57 const entry = totals?.byProvider.get(provider);
58 if (entry === undefined) return 0;
59 return metric === "tokens" ? entry.totalTokens : entry.costUsd;
60}
61
62export function buildPeriodColumns(
63 periods: readonly string[],
64 byPeriod: ReadonlyMap<string, DailyTotals | HourlyTotals>,
65 metric: UsageChartMetric,
66): readonly DayColumn[] {
67 return periods.map((period) => {
68 const entry = byPeriod.get(period);
69 const bands = PROVIDER_ORDER.map((provider) => ({
70 provider,
71 value: valueFor(entry, provider, metric),
72 }));
73 return { bands, total: bands.reduce((sum, band) => sum + band.value, 0) };
74 });
75}
76
77function monotoneTangents(points: readonly Point[]): readonly number[] {
78 const count = points.length;
79 if (count < 2) return [0];
80
81 const slopes: number[] = [];
82 for (let index = 0; index < count - 1; index += 1) {
83 const dx = (points[index + 1]?.x ?? 0) - (points[index]?.x ?? 0);
84 const dy = (points[index + 1]?.y ?? 0) - (points[index]?.y ?? 0);
85 slopes.push(dx === 0 ? 0 : dy / dx);
86 }
87
88 const tangents: number[] = Array.from({ length: count }, () => 0);
89 tangents[0] = slopes[0] ?? 0;
90 tangents[count - 1] = slopes[count - 2] ?? 0;
91 for (let index = 1; index < count - 1; index += 1) {
92 const previous = slopes[index - 1] ?? 0;
93 const next = slopes[index] ?? 0;
94 tangents[index] = previous * next <= 0 ? 0 : (previous + next) / 2;
95 }
96
97 for (let index = 0; index < count - 1; index += 1) {
98 const slope = slopes[index] ?? 0;
99 if (slope === 0) {
100 tangents[index] = 0;
101 tangents[index + 1] = 0;
102 continue;
103 }
104 const a = (tangents[index] ?? 0) / slope;
105 const b = (tangents[index + 1] ?? 0) / slope;
106 const magnitude = a * a + b * b;
107 if (magnitude > 9) {
108 const scale = 3 / Math.sqrt(magnitude);
109 tangents[index] = scale * a * slope;
110 tangents[index + 1] = scale * b * slope;
111 }
112 }
113
114 return tangents;
115}
116
117interface CurveSegment {
118 readonly from: Point;
119 readonly c1: Point;
120 readonly c2: Point;
121 readonly to: Point;
122}
123
124function smoothCurve(points: readonly Point[]): readonly CurveSegment[] {
125 if (points.length < 2) return [];
126 const tangents = monotoneTangents(points);
127 const segments: CurveSegment[] = [];
128
129 for (let index = 0; index < points.length - 1; index += 1) {
130 const from = points[index];
131 const to = points[index + 1];
132 if (from === undefined || to === undefined) continue;
133 const dx = to.x - from.x;
134 segments.push({
135 from,
136 c1: { x: from.x + dx / 3, y: from.y + ((tangents[index] ?? 0) * dx) / 3 },
137 c2: { x: to.x - dx / 3, y: to.y - ((tangents[index + 1] ?? 0) * dx) / 3 },
138 to,
139 });
140 }
141 return segments;
142}
143
144function curvePath(segments: readonly CurveSegment[]): string {
145 const first = segments[0];
146 if (first === undefined) return "";
147 let path = `M${first.from.x.toFixed(2)},${first.from.y.toFixed(2)}`;
148 for (const segment of segments) {
149 path += ` C${segment.c1.x.toFixed(2)},${segment.c1.y.toFixed(2)} ${segment.c2.x.toFixed(2)},${segment.c2.y.toFixed(2)} ${segment.to.x.toFixed(2)},${segment.to.y.toFixed(2)}`;
150 }
151 return path;
152}
153
154function areaPath(line: string) {
155 return line === "" ? "" : `${line} L${VIEW_WIDTH},${VIEW_HEIGHT} L0,${VIEW_HEIGHT} Z`;
156}
157
158function niceScale(peak: number, count: number): { max: number; ticks: readonly number[] } {
159 if (peak <= 0) return { max: 0, ticks: [0] };
160
161 const rawStep = peak / count;
162 const magnitude = 10 ** Math.floor(Math.log10(rawStep));
163 const normalized = rawStep / magnitude;
164 const step = (normalized > 5 ? 10 : normalized > 2 ? 5 : normalized > 1 ? 2 : 1) * magnitude;
165
166 const max = Math.ceil(peak / step) * step;
167 const ticks: number[] = [];
168 for (let value = 0; value <= max + step * 1e-6; value += step) ticks.push(value);
169 return { max, ticks };
170}
171
172const PLACEHOLDER_TICKS = Array.from({ length: TICK_COUNT + 1 }, (_, index) => index);
173
174function chartScale(
175 columns: readonly DayColumn[],
176 loadingProviders: ReadonlySet<UsageProviderKind>,
177) {
178 // Layered series each start at zero; summing peaks would waste plot height.
179 const peak = columns.reduce(
180 (max, column) => column.bands.reduce((inner, band) => Math.max(inner, band.value), max),
181 0,
182 );
183 return peak === 0 && loadingProviders.size > 0
184 ? { max: TICK_COUNT, ticks: PLACEHOLDER_TICKS, labeled: false }
185 : { ...niceScale(peak, TICK_COUNT), labeled: true };
186}
187
188function valueToY(value: number, max: number) {
189 return max === 0 ? VIEW_HEIGHT : VIEW_HEIGHT - (value / max) * (VIEW_HEIGHT - PLOT_TOP);
190}
191
192function buildChart(
193 periods: readonly string[],
194 byPeriod: ReadonlyMap<string, DailyTotals | HourlyTotals>,
195 metric: UsageChartMetric,
196 providers: readonly UsageProviderKind[],
197 loadingProviders: ReadonlySet<UsageProviderKind>,
198) {
199 const columns = buildPeriodColumns(periods, byPeriod, metric);
200 const scale = chartScale(columns, loadingProviders);
201 const stepX = periods.length < 2 ? 0 : VIEW_WIDTH / (periods.length - 1);
202 const paths = providers.map((provider) => {
203 const slot = PROVIDER_ORDER.indexOf(provider);
204 const line = curvePath(
205 smoothCurve(
206 columns.map((column, periodIndex) => ({
207 x: periodIndex * stepX,
208 y: valueToY(column.bands[slot]?.value ?? 0, scale.max),
209 })),
210 ),
211 );
212 return {
213 provider,
214 loading: loadingProviders.has(provider),
215 total: columns.reduce((sum, column) => sum + (column.bands[slot]?.value ?? 0), 0),
216 line,
217 area: areaPath(line),
218 };
219 });
220
221 return { columns, scale, stepX, paths: paths.toSorted((a, b) => b.total - a.total) };
222}
223
224function UsageChartTooltip({
225 tooltipRef,
226 label,
227 column,
228 providers,
229 loadingProviders,
230 format,
231}: {
232 readonly tooltipRef: React.Ref<HTMLDivElement>;
233 readonly label: string;
234 readonly column: DayColumn | undefined;
235 readonly providers: readonly UsageProviderKind[];
236 readonly loadingProviders: ReadonlySet<UsageProviderKind>;
237 readonly format: (value: number) => string;
238}) {
239 const partial = providers.some((provider) => loadingProviders.has(provider));
240 return (
241 <div
242 ref={tooltipRef}
243 className="surface-glass pointer-events-none absolute z-10 min-w-36 max-w-full rounded-xl border border-border/50 px-2.5 py-2 text-xs shadow-lg"
244 style={{
245 left: "var(--usage-tooltip-left, 0px)",
246 top: "var(--usage-tooltip-top, 0px)",
247 }}
248 >
249 <div className="mb-1 text-muted-foreground">{label}</div>
250 {providers.map((provider) => {
251 const { label: providerLabel, driverKind } = PROVIDER_PRESENTATION[provider];
252 return (
253 <div key={provider} className="flex items-center justify-between gap-3">
254 <span className="flex items-center gap-1.5 text-muted-foreground">
255 <ProviderInstanceIcon
256 driverKind={driverKind}
257 displayName={providerLabel}
258 iconClassName="size-3"
259 />
260 {providerLabel}
261 </span>
262 <span
263 className={cn(
264 "tabular-nums",
265 loadingProviders.has(provider) ? "text-muted-foreground" : "text-foreground",
266 )}
267 >
268 {format(column?.bands.find((band) => band.provider === provider)?.value ?? 0)}
269 </span>
270 </div>
271 );
272 })}
273 <div className="mt-1 flex items-center justify-between gap-3 border-t border-border pt-1">
274 <span className="text-muted-foreground">Total</span>
275 <span className={cn("tabular-nums", partial ? "text-muted-foreground" : "text-foreground")}>
276 {format(column?.total ?? 0)}
277 </span>
278 </div>
279 </div>
280 );
281}
282
283function UsageChartPlot({
284 periods,
285 columns,
286 stepX,
287 providers,
288 loadingProviders,
289 format,
290 formatTooltipPeriod,
291 ariaLabel,
292 children,
293}: {
294 readonly periods: readonly string[];
295 readonly columns: readonly DayColumn[];
296 readonly stepX: number;
297 readonly providers: readonly UsageProviderKind[];
298 readonly loadingProviders: ReadonlySet<UsageProviderKind>;
299 readonly format: (value: number) => string;
300 readonly formatTooltipPeriod: (period: string) => string;
301 readonly ariaLabel: string;
302 readonly children: React.ReactNode;
303}) {
304 const [hoverIndex, setHoverIndex] = useState<number | null>(null);
305 const plotRef = useRef<HTMLDivElement | null>(null);
306 const tooltipRef = useRef<HTMLDivElement | null>(null);
307 const hoverPositionRef = useRef<{ x: number; y: number } | null>(null);
308
309 const positionTooltip = () => {
310 const plot = plotRef.current;
311 const tooltip = tooltipRef.current;
312 const hoverPosition = hoverPositionRef.current;
313 if (plot === null || tooltip === null || hoverPosition === null) return;
314
315 const gap = 12;
316 const tooltipWidth = tooltip.offsetWidth;
317 const tooltipHeight = tooltip.offsetHeight;
318 const plotWidth = plot.clientWidth;
319 const plotHeight = plot.clientHeight;
320 const preferredLeft =
321 hoverPosition.x + gap + tooltipWidth <= plotWidth
322 ? hoverPosition.x + gap
323 : hoverPosition.x - gap - tooltipWidth;
324 const preferredTop =
325 hoverPosition.y + gap + tooltipHeight <= plotHeight
326 ? hoverPosition.y + gap
327 : hoverPosition.y - gap - tooltipHeight;
328 const left = Math.min(Math.max(0, preferredLeft), Math.max(0, plotWidth - tooltipWidth));
329 const top = Math.min(Math.max(0, preferredTop), Math.max(0, plotHeight - tooltipHeight));
330 plot.style.setProperty("--usage-tooltip-left", `${left}px`);
331 plot.style.setProperty("--usage-tooltip-top", `${top}px`);
332 };
333
334 // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- positions the hover tooltip through plot CSS variables before paint and on ResizeObserver
335 useLayoutEffect(() => {
336 if (hoverIndex === null) return;
337 positionTooltip();
338
339 const plot = plotRef.current;
340 const tooltip = tooltipRef.current;
341 if (plot === null || tooltip === null) return;
342
343 return observeResize([plot, tooltip], positionTooltip);
344 }, [hoverIndex, positionTooltip]);
345
346 const handleMove = (event: React.MouseEvent<HTMLDivElement>) => {
347 const plot = plotRef.current;
348 if (plot === null || periods.length === 0) return;
349 const bounds = plot.getBoundingClientRect();
350 if (bounds.width === 0) return;
351 const localX = Math.min(bounds.width, Math.max(0, event.clientX - bounds.left));
352 const localY = Math.min(bounds.height, Math.max(0, event.clientY - bounds.top));
353 const fraction = localX / bounds.width;
354 const index = Math.round(fraction * (periods.length - 1));
355 hoverPositionRef.current = { x: localX, y: localY };
356 positionTooltip();
357 setHoverIndex(Math.min(periods.length - 1, Math.max(0, index)));
358 };
359
360 const hoveredPeriod = hoverIndex === null ? undefined : periods[hoverIndex];
361
362 return (
363 <div
364 ref={plotRef}
365 className="relative h-56 flex-1"
366 onMouseMove={handleMove}
367 onMouseLeave={() => {
368 hoverPositionRef.current = null;
369 setHoverIndex(null);
370 }}
371 >
372 <svg
373 className="h-full w-full"
374 viewBox={`0 0 ${VIEW_WIDTH} ${VIEW_HEIGHT}`}
375 preserveAspectRatio="none"
376 role="img"
377 aria-label={ariaLabel}
378 >
379 {children}
380 {hoverIndex === null ? null : (
381 <line
382 x1={hoverIndex * stepX}
383 x2={hoverIndex * stepX}
384 y1={PLOT_TOP}
385 y2={VIEW_HEIGHT}
386 stroke="currentColor"
387 strokeWidth={1}
388 className="text-muted-foreground"
389 vectorEffect="non-scaling-stroke"
390 />
391 )}
392 </svg>
393
394 {hoverIndex === null || hoveredPeriod === undefined ? null : (
395 <UsageChartTooltip
396 tooltipRef={tooltipRef}
397 label={formatTooltipPeriod(hoveredPeriod)}
398 column={columns[hoverIndex]}
399 providers={providers}
400 loadingProviders={loadingProviders}
401 format={format}
402 />
403 )}
404 </div>
405 );
406}
407
408export function UsageProviderChart({
409 providers,
410 loadingProviders = NONE_LOADING,
411 days,
412 daily,
413 hours,
414 hourly,
415 metric,
416 referenceTime,
417 resolution,
418 timeZone,
419 hour12,
420}: UsageProviderChartProps) {
421 const periods = resolution === "hour" ? hours : days;
422 const totals: readonly (DailyTotals | HourlyTotals)[] = resolution === "hour" ? hourly : daily;
423 const byPeriod = new Map(
424 totals.map((entry) => ["hourStart" in entry ? entry.hourStart : entry.day, entry]),
425 );
426 const { columns, scale, paths, stepX } = buildChart(
427 periods,
428 byPeriod,
429 metric,
430 providers,
431 loadingProviders,
432 );
433
434 const toY = (value: number) => valueToY(value, scale.max);
435 const seriesClassName = (loading: boolean) =>
436 cn("transition-opacity", loading && "opacity-40 delay-150");
437 const format = metric === "tokens" ? formatTokens : formatUsd;
438 const formatPeriod = (period: string) =>
439 resolution === "hour" ? formatHourShort(period, timeZone, hour12) : formatDayShort(period);
440 const formatTooltipPeriod = (period: string) =>
441 resolution === "hour" && referenceTime !== undefined
442 ? formatRelativeHourShort(period, referenceTime, timeZone, hour12)
443 : formatPeriod(period);
444
445 return (
446 <div className="flex flex-col gap-1">
447 <div className="flex gap-2">
448 <div className="relative h-56 w-14 shrink-0">
449 {scale.labeled
450 ? scale.ticks.map((tick) => (
451 <span
452 key={tick}
453 className="absolute right-0 -translate-y-1/2 text-3xs text-muted-foreground tabular-nums"
454 style={{ top: `${(toY(tick) / VIEW_HEIGHT) * 100}%` }}
455 >
456 {tick === 0 ? "0" : format(tick)}
457 </span>
458 ))
459 : null}
460 </div>
461
462 <UsageChartPlot
463 periods={periods}
464 columns={columns}
465 stepX={stepX}
466 providers={providers}
467 loadingProviders={loadingProviders}
468 format={format}
469 formatTooltipPeriod={formatTooltipPeriod}
470 ariaLabel={`${resolution === "hour" ? "Hourly" : "Daily"} ${metric === "tokens" ? "processed tokens" : "cost"} by provider`}
471 >
472 {scale.ticks.map((tick) => {
473 const y = toY(tick);
474 return (
475 <line
476 key={tick}
477 x1={0}
478 x2={VIEW_WIDTH}
479 y1={y}
480 y2={y}
481 stroke="currentColor"
482 strokeWidth={1}
483 className="text-border"
484 vectorEffect="non-scaling-stroke"
485 />
486 );
487 })}
488
489 {paths.map(({ provider, loading, area }) => (
490 <path
491 key={provider}
492 d={area}
493 className={seriesClassName(loading)}
494 fill={PROVIDER_PRESENTATION[provider].color}
495 fillOpacity={0.12}
496 />
497 ))}
498 {paths.map(({ provider, loading, line }) => (
499 <path
500 key={provider}
501 d={line}
502 className={seriesClassName(loading)}
503 fill="none"
504 stroke={PROVIDER_PRESENTATION[provider].color}
505 strokeWidth={2}
506 vectorEffect="non-scaling-stroke"
507 />
508 ))}
509 </UsageChartPlot>
510 </div>
511
512 <div className="flex justify-between pl-16 text-3xs text-muted-foreground uppercase">
513 <span>{periods[0] === undefined ? "" : formatPeriod(periods[0])}</span>
514 <span>
515 {periods[Math.floor(periods.length / 2)] === undefined
516 ? ""
517 : formatPeriod(periods[Math.floor(periods.length / 2)] ?? "")}
518 </span>
519 <span>
520 {periods[periods.length - 1] === undefined
521 ? ""
522 : formatPeriod(periods[periods.length - 1] ?? "")}
523 </span>
524 </div>
525 </div>
526 );
527}