feat: add live playground forecast console
ci / check (push) Successful in 1m20s

This commit is contained in:
Noel Sabia committed 2026-11-14 21:04:23 +01:00
1 parent 9ba70965ba
commit bcee6b2c68
9 files changed
+1931 -12

No files matched your search

+165
View File
@@ -0,0 +1,165 @@
import type { Point } from '../../shared/types'
export const HEATMAP_HOURS = [8, 10, 12, 14, 16, 18] as const
const partsFormatter = new Intl.DateTimeFormat('en-CA', {
timeZone: 'Europe/Berlin',
year: 'numeric',
month: '2-digit',
day: '2-digit',
hour: '2-digit',
minute: '2-digit',
hourCycle: 'h23',
})
function berlinParts(iso: string): { date: string; hour: number; weekday: number } {
const parts = Object.fromEntries(
partsFormatter.formatToParts(new Date(iso)).map((part) => [part.type, part.value]),
)
const date = `${parts.year}-${parts.month}-${parts.day}`
return {
date,
hour: Number(parts.hour),
weekday: (new Date(`${date}T12:00:00Z`).getUTCDay() + 6) % 7,
}
}
export interface ForecastSummary {
count: number
peak: Point | null
mean: number
total: number
intervalHours: number
}
export interface HeatmapCell {
hour: number
value: number | null
intensity: number
}
export interface HeatmapRow {
date: string
weekday: number
cells: HeatmapCell[]
}
export interface Heatmap {
hours: number[]
rows: HeatmapRow[]
max: number
}
export interface ScenarioDelta {
peakDelta: number
peakDeltaPct: number | null
meanDelta: number
meanDeltaPct: number | null
}
export function summarizeForecast(points: Point[]): ForecastSummary {
if (!points.length) {
return { count: 0, peak: null, mean: 0, total: 0, intervalHours: 1 }
}
const sorted = [...points].sort((a, b) => Date.parse(a.t) - Date.parse(b.t))
const first = Date.parse(sorted[0]!.t)
const second = Date.parse(sorted[1]?.t ?? sorted[0]!.t)
const intervalHours = sorted.length > 1 && Number.isFinite(second - first) && second > first
? (second - first) / 3_600_000
: 1
let peak = sorted[0]!
let total = 0
for (const point of sorted) {
total += point.v
if (point.v > peak.v) peak = point
}
return {
count: sorted.length,
peak,
mean: total / sorted.length,
total: total * intervalHours,
intervalHours,
}
}
export function formatBand(lo?: number | null, hi?: number | null): string {
if (
lo === null ||
lo === undefined ||
hi === null ||
hi === undefined ||
!Number.isFinite(lo) ||
!Number.isFinite(hi)
) {
return '—'
}
const format = (value: number) => (Number.isInteger(value) ? String(value) : value.toFixed(1))
return `${format(lo)} – ${format(hi)}`
}
export function scenarioDelta(selected: ForecastSummary, base: ForecastSummary): ScenarioDelta {
const selectedPeak = selected.peak?.v ?? 0
const basePeak = base.peak?.v ?? 0
const peakDelta = selectedPeak - basePeak
const meanDelta = selected.mean - base.mean
return {
peakDelta,
peakDeltaPct: basePeak ? (peakDelta / basePeak) * 100 : null,
meanDelta,
meanDeltaPct: base.mean ? (meanDelta / base.mean) * 100 : null,
}
}
/** Group forecast points into local Berlin weekday × exact-hour cells. */
export function buildHeatmap(points: Point[]): Heatmap {
const buckets = new Map<string, { date: string; weekday: number; hour: number; sum: number; count: number }>()
for (const point of points) {
const local = berlinParts(point.t)
if (!HEATMAP_HOURS.includes(local.hour as (typeof HEATMAP_HOURS)[number])) continue
const key = `${local.date}|${local.hour}`
const bucket = buckets.get(key)
if (bucket) {
bucket.sum += point.v
bucket.count += 1
} else {
buckets.set(key, {
date: local.date,
weekday: local.weekday,
hour: local.hour,
sum: point.v,
count: 1,
})
}
}
const dates = [...new Set([...buckets.values()].map((bucket) => bucket.date))].sort()
let maximum = 0
for (const bucket of buckets.values()) {
maximum = Math.max(maximum, bucket.sum / bucket.count)
}
return {
hours: [...HEATMAP_HOURS],
max: maximum,
rows: dates.map((date) => {
const dayBuckets = [...buckets.values()].filter((bucket) => bucket.date === date)
return {
date,
weekday: dayBuckets[0]?.weekday ?? 0,
cells: HEATMAP_HOURS.map((hour) => {
const bucket = dayBuckets.find((item) => item.hour === hour)
const value = bucket ? bucket.sum / bucket.count : null
return {
hour,
value,
intensity: value === null || maximum <= 0 ? 0 : Math.min(1, value / maximum),
}
}),
}
}),
}
}