166 lines
4.3 KiB
TypeScript
166 lines
4.3 KiB
TypeScript
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),
|
||
}
|
||
}),
|
||
}
|
||
}),
|
||
}
|
||
}
|