Files
web-nuxt/app/utils/playground.ts
T
2026-11-14 21:04:23 +01:00

166 lines
4.3 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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),
}
}),
}
}),
}
}