feat(dashboard): Analytics-Dashboard als Gestaltungsvorlage zur Übergabe

UI/UX-Prototyp der Analytics-Dashboards in HiveGrid, fachlich auf einen
SHK-/Handwerksbetrieb zugeschnitten. Ziel ist die Übergabe an die Entwicklung,
nicht der Produktivbetrieb.

Inhalt: sechs Seiten (Übersicht, Finanzen, Aufträge, Kunden, Team, Komponenten),
26 KPIs, neun Chart-Bausteine, Filtersystem mit seitenabhängiger Relevanz und ein
deterministischer Demo-Datensatz (420 Kunden, 1.900 Aufträge, Stichtag 30.07.2026).

Drei Quellen sind zusammengeführt: die fachliche Planung mit dem Branchenpartner
(Januar 2026), die Subframe-Komponentenbibliothek aus dem HiveGrid-Pitch und
IBM Carbon Data Visualization für die Diagrammregeln. Herkunft und bewusste
Abweichungen stehen in docs/HERKUNFT.md.

Dokumentation: README, HANDOVER (was echte Logik braucht), docs/DESIGN-SYSTEM,
KPI-KATALOG, DATENMODELL, NAVIGATION, HERKUNFT, ZIELSYSTEM (Einbauort in
HiveGrid Cloud) und LEITPLANKEN (welche Cloud-Screens als Vorbild taugen).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QPeZNwSeU7qG3RRCwaxEZX
This commit is contained in:
dejanandClaude Opus 5 committed 2026-08-29 17:25:20 +02:00
commit b8bf987d0e
250 files changed
+33153

No files matched your search

@@ -0,0 +1,131 @@
"use client";
import React from "react";
import {
Area,
CartesianGrid,
ComposedChart,
Line,
ResponsiveContainer,
Tooltip,
XAxis,
YAxis,
} from "recharts";
import { ChartTooltip } from "./ChartTooltip";
import { ChartLeer } from "./ChartLeer";
import {
CHART,
MARGIN,
MAX_ACHSENLABELS,
PRIMAER_FARBE,
VERGLEICH_FARBE,
achseX,
achseY,
nettesRaster,
} from "../../utils/chartTheme";
import type { ZeitreihePunkt } from "../../data/types";
/**
* Zeitverlauf als Fläche mit optionaler Vergleichslinie (Vorjahr).
*
* Bewusst `ComposedChart`, nicht `AreaChart`: Recharts sammelt in einem
* AreaChart ausschließlich `Area`-Kinder ein (generateCategoricalChart mit
* GraphicalChild = Area). Ein `<Line>` darin wird stillschweigend verworfen —
* die Vergleichsreihe stand monatelang in der Legende, ohne je gezeichnet zu
* werden. ComposedChart nimmt beide Typen.
*
* Carbon-Regeln, die hier umgesetzt sind:
* - nur horizontale Gridlines (#e0e0e0), vertikale lenken ab
* - keine Tick-Marks, Achsenbeschriftung 12 px in #525252
* - lineare Interpolation: eine Monotone-Kurve erfindet Zwischenwerte
* zwischen zwei Messpunkten, die es nicht gibt
* - Vergleichsreihe gestrichelt und neutral, damit sie die Hauptreihe
* nicht um Aufmerksamkeit bringt
*/
export function AreaVerlauf({
daten,
formatWert,
/** Kürzere Schreibweise für die Y-Achse; ohne Angabe wie formatWert. */
formatAchse,
hoehe = 260,
zeigeVergleich = false,
farbe = PRIMAER_FARBE,
labelPrefix,
}: {
daten: ZeitreihePunkt[];
formatWert: (wert: number) => string;
formatAchse?: (wert: number) => string;
hoehe?: number;
zeigeVergleich?: boolean;
farbe?: string;
labelPrefix?: string;
}) {
// Zwei Verläufe auf einer Seite dürfen sich keinen Gradienten teilen.
const gradientId = `verlauf-${React.useId().replace(/:/g, "")}`;
const hatWerte = daten.some((d) => d.value > 0 || (d.vergleich ?? 0) > 0);
if (!daten.length || !hatWerte) return <ChartLeer hoehe={hoehe} />;
// Bei vielen Punkten nur jede n-te Beschriftung zeigen, sonst überlappen sie.
const intervall =
daten.length > MAX_ACHSENLABELS ? Math.ceil(daten.length / MAX_ACHSENLABELS) - 1 : 0;
const maximum = Math.max(
...daten.map((d) => Math.max(d.value, zeigeVergleich ? (d.vergleich ?? 0) : 0))
);
const raster = nettesRaster(maximum);
return (
<div style={{ height: hoehe }}>
<ResponsiveContainer width="100%" height="100%">
<ComposedChart data={daten} margin={MARGIN.standard}>
<defs>
<linearGradient id={gradientId} x1="0" y1="0" x2="0" y2="1">
<stop offset="0%" stopColor={farbe} stopOpacity={0.24} />
<stop offset="100%" stopColor={farbe} stopOpacity={0.02} />
</linearGradient>
</defs>
<CartesianGrid stroke={CHART.grid} vertical={false} />
<XAxis dataKey="label" interval={intervall} {...achseX} />
<YAxis
domain={raster.domain}
ticks={raster.ticks}
tickFormatter={formatAchse ?? formatWert}
{...achseY}
/>
<Tooltip
cursor={{ stroke: CHART.achse, strokeWidth: 1, strokeDasharray: "3 3" }}
content={(props) => (
<ChartTooltip {...props} formatWert={formatWert} labelPrefix={labelPrefix} />
)}
/>
<Area
type="linear"
dataKey="value"
name="Aktueller Zeitraum"
stroke={farbe}
strokeWidth={2}
fill={`url(#${gradientId})`}
dot={false}
activeDot={{ r: 4, fill: farbe, stroke: "#fff", strokeWidth: 2 }}
/>
{zeigeVergleich ? (
<Line
type="linear"
dataKey="vergleich"
name="Vorjahr"
stroke={VERGLEICH_FARBE}
strokeWidth={1.5}
strokeDasharray="4 4"
dot={false}
activeDot={{ r: 4, fill: VERGLEICH_FARBE, stroke: "#fff", strokeWidth: 2 }}
/>
) : null}
</ComposedChart>
</ResponsiveContainer>
</div>
);
}
@@ -0,0 +1,135 @@
"use client";
import React from "react";
import { CHART, STATUS_FARBEN } from "../../utils/chartTheme";
import { ChartLeer } from "./ChartLeer";
/**
* Auslastung je Person als Punktdiagramm mit Zielkorridor.
*
* Warum kein Balken: Auslastungswerte liegen im Betrieb zwischen etwa 70 und
* 100 %. Ein Balken muss bei 0 beginnen (sonst verzerrt die Länge), und dann
* sind 74 % und 96 % optisch fast gleich lang — das Diagramm zeigt nichts.
* Ein Punkt kodiert über die Position, nicht über die Länge, und darf deshalb
* einen ausgeschnittenen Bereich zeigen. Carbon nennt das Dot-Plot.
*
* Die Schwellen sind betrieblich gedacht, nicht mathematisch:
* < 70 % Luft frei — Kapazität ungenutzt
* 70–95 % Zielkorridor
* > 95 % ausgebucht — Überlastrisiko, Termine gefährdet
* Der Korridor liegt als graues Band hinter den Punkten, die 100-%-Marke als
* beschriftete Linie. Damit erklärt sich die Grafik ohne Ampel-Legende.
*/
const SCHWELLEN = { frei: 70, ausgebucht: 95 };
export function AuslastungsBalken({
zeilen,
maxZeilen = 8,
}: {
zeilen: { name: string; wert: number; zusatz?: string }[];
maxZeilen?: number;
}) {
const [aktiv, setAktiv] = React.useState<string | null>(null);
const sichtbar = zeilen.slice(0, maxZeilen);
if (!sichtbar.length) return <ChartLeer hoehe={200} />;
// Skala umschließt die Daten, bleibt aber mindestens 60–110 %, damit der
// Zielkorridor immer als Fläche erkennbar ist.
const min = Math.min(60, Math.floor(Math.min(...sichtbar.map((z) => z.wert)) / 10) * 10);
const max = Math.max(110, Math.ceil(Math.max(...sichtbar.map((z) => z.wert)) / 10) * 10);
const pos = (wert: number) => ((Math.min(Math.max(wert, min), max) - min) / (max - min)) * 100;
const ticks = [];
for (let t = min; t <= max; t += 10) ticks.push(t);
return (
<div className="flex flex-col gap-2">
{sichtbar.map((zeile) => {
const farbe =
zeile.wert < SCHWELLEN.frei
? STATUS_FARBEN.info
: zeile.wert <= SCHWELLEN.ausgebucht
? STATUS_FARBEN.positiv
: STATUS_FARBEN.warnung;
const hervorgehoben = aktiv === zeile.name;
return (
<div
key={zeile.name}
onMouseEnter={() => setAktiv(zeile.name)}
onMouseLeave={() => setAktiv(null)}
className="grid grid-cols-[minmax(96px,24%)_minmax(0,1fr)_48px] items-center gap-3"
>
<span className="flex min-w-0 flex-col">
<span className="truncate text-[12px] text-text-neutral-secondary">{zeile.name}</span>
{zeile.zusatz ? (
<span className="truncate text-[11px] text-text-neutral-tertiary">
{zeile.zusatz}
</span>
) : null}
</span>
<span className="relative block h-5 w-full">
{/* Zielkorridor als ruhiges Band hinter allen Zeilen */}
<span
className="absolute top-1/2 h-4 -translate-y-1/2 rounded-sm bg-neutral-100"
style={{
left: `${pos(SCHWELLEN.frei)}%`,
width: `${pos(SCHWELLEN.ausgebucht) - pos(SCHWELLEN.frei)}%`,
}}
aria-hidden="true"
/>
{/* Grundlinie */}
<span
className="absolute top-1/2 h-px w-full -translate-y-1/2"
style={{ background: CHART.grid }}
aria-hidden="true"
/>
{/* 100-%-Marke */}
<span
className="absolute top-0 h-full w-px"
style={{ left: `${pos(100)}%`, background: CHART.achse }}
aria-hidden="true"
/>
<span
className="absolute top-1/2 block h-2.5 w-2.5 -translate-x-1/2 -translate-y-1/2 rounded-full ring-2 ring-white transition-opacity duration-200"
style={{
left: `${pos(zeile.wert)}%`,
background: farbe,
opacity: aktiv && !hervorgehoben ? 0.45 : 1,
}}
title={`${zeile.name}: ${zeile.wert.toFixed(0)} %`}
/>
</span>
<span className="text-right text-[12px] font-semibold tabular-nums text-text-neutral-primary">
{zeile.wert.toFixed(0)} %
</span>
</div>
);
})}
{/* Achse statt Farblegende — die Zonen erklären sich über das Band. */}
<div className="grid grid-cols-[minmax(96px,24%)_minmax(0,1fr)_48px] items-center gap-3 pt-1">
<span />
<span className="relative block h-4">
{ticks.map((t) => (
<span
key={t}
className="absolute top-0 -translate-x-1/2 text-[11px] tabular-nums text-text-neutral-tertiary"
style={{ left: `${pos(t)}%` }}
>
{t}
</span>
))}
</span>
<span className="text-right text-[11px] text-text-neutral-tertiary">%</span>
</div>
<p className="border-t border-solid border-border-default pt-2 text-[11px] text-text-neutral-tertiary">
Graues Band = Zielkorridor {SCHWELLEN.frei}–{SCHWELLEN.ausgebucht} %, Linie = 100 % der
vertraglichen Stunden.
</p>
</div>
);
}
@@ -0,0 +1,96 @@
"use client";
import React from "react";
import { farbeFuer, farbe as paletteFarbe } from "../../utils/chartTheme";
import { ChartLeer } from "./ChartLeer";
/**
* Horizontale Balken für Rangfolgen (Top-Kunden, Aufträge je Gewerk).
*
* Bewusst als HTML/CSS statt Recharts: Kategorienamen sind hier lang und
* unterschiedlich breit; im SVG müsste man sie hart abschneiden. In HTML
* bleiben sie umbruchfähig, selektierbar und barrierefrei lesbar.
* Hover hebt den Balken hervor und zeigt den vollen Namen als Titel.
*/
export function BalkenHorizontal({
daten,
formatWert,
maxBalken = 6,
/**
* Einfarbig für Rangfolgen (Top-Kunden, Aufträge je Mitarbeiter):
* Dort trägt die Farbe keine Information und würde nur Unruhe erzeugen.
* Palette nur, wenn die Balken echte Kategorien sind.
*/
einfarbig = true,
farbeStart = 1,
/**
* Zweitwert rechts neben dem Hauptwert — z. B. Auftragswert neben der
* Anzahl Abschlüsse. Erspart eine zweite Karte mit derselben Kodierung
* auf derselben Personenachse.
*/
formatZweitwert,
}: {
daten: { name: string; value: number; zweitwert?: number }[];
formatWert: (wert: number) => string;
maxBalken?: number;
einfarbig?: boolean;
farbeStart?: number;
formatZweitwert?: (wert: number) => string;
}) {
const [aktiv, setAktiv] = React.useState<string | null>(null);
const sichtbar = [...daten]
.filter((d) => d.value > 0)
.sort((a, b) => b.value - a.value)
.slice(0, maxBalken);
if (!sichtbar.length) return <ChartLeer hoehe={180} />;
const max = Math.max(...sichtbar.map((d) => d.value));
return (
<ul className="flex flex-col gap-2.5">
{sichtbar.map((eintrag, index) => {
const anteil = max > 0 ? (eintrag.value / max) * 100 : 0;
const balkenFarbe = einfarbig
? paletteFarbe(1)
: farbeFuer(eintrag.name, farbeStart + index);
const hervorgehoben = aktiv === eintrag.name;
return (
<li
key={eintrag.name}
title={eintrag.name}
onMouseEnter={() => setAktiv(eintrag.name)}
onMouseLeave={() => setAktiv(null)}
className="grid grid-cols-[minmax(0,1fr)_auto] items-center gap-x-3 gap-y-1"
>
<span className="min-w-0 truncate text-[12px] text-text-neutral-secondary">
{eintrag.name}
</span>
<span className="flex items-baseline gap-2 whitespace-nowrap tabular-nums">
<span className="text-[12px] font-semibold text-text-neutral-primary">
{formatWert(eintrag.value)}
</span>
{formatZweitwert && eintrag.zweitwert !== undefined ? (
<span className="text-[12px] text-text-neutral-tertiary">
{formatZweitwert(eintrag.zweitwert)}
</span>
) : null}
</span>
<span className="col-span-2 block h-2.5 w-full overflow-hidden rounded-sm bg-neutral-100">
<span
className="block h-full rounded-r-sm transition-[width,opacity] duration-300"
style={{
width: `${Math.max(2, anteil)}%`,
background: balkenFarbe,
opacity: aktiv && !hervorgehoben ? 0.45 : 1,
}}
/>
</span>
</li>
);
})}
</ul>
);
}
@@ -0,0 +1,106 @@
"use client";
import React from "react";
import { Bar, BarChart, CartesianGrid, Cell, ResponsiveContainer, Tooltip, XAxis, YAxis } from "recharts";
import { ChartTooltip } from "./ChartTooltip";
import { ChartLeer } from "./ChartLeer";
import {
BALKEN,
CHART,
MARGIN,
MAX_ACHSENLABELS,
PRIMAER_FARBE,
achseX,
achseY,
nettesRaster,
} from "../../utils/chartTheme";
/**
* Vertikale Balken für Mengen über Zeit oder Kategorien mit Nulllinie.
* Balkenbreite ist gedeckelt (Carbon: Abstand ≥ halbe Balkenbreite),
* damit vier Balken nicht wie Flächen wirken.
*/
export function BalkenVertikal({
daten,
formatWert,
/** Kürzere Schreibweise für die Y-Achse; ohne Angabe wie formatWert. */
formatAchse,
hoehe = 240,
farbe = PRIMAER_FARBE,
/** Einzelne Balken einfärben, z. B. Alters-Buckets von grün nach rot. */
farbenProBalken,
/** Bei Stückzahlen: keine Zwischenwerte auf der Achse ("1, 1, 2, 2"). */
nurGanzzahlen = false,
labelPrefix,
}: {
daten: { name?: string; label?: string; value: number }[];
formatWert: (wert: number) => string;
formatAchse?: (wert: number) => string;
hoehe?: number;
farbe?: string;
farbenProBalken?: string[];
nurGanzzahlen?: boolean;
labelPrefix?: string;
}) {
const [aktiv, setAktiv] = React.useState<number | null>(null);
const punkte = daten.map((d) => ({ label: d.label ?? d.name ?? "", value: d.value }));
if (!punkte.length || !punkte.some((p) => p.value > 0)) return <ChartLeer hoehe={hoehe} />;
const intervall =
punkte.length > MAX_ACHSENLABELS ? Math.ceil(punkte.length / MAX_ACHSENLABELS) - 1 : 0;
// Ganzzahlreihen brauchen ganzzahlige Ticks — sonst steht "1,5 Vorgänge".
const maximum = Math.max(...punkte.map((p) => p.value));
const raster = nurGanzzahlen
? undefined
: nettesRaster(maximum);
return (
<div style={{ height: hoehe }}>
<ResponsiveContainer width="100%" height="100%">
<BarChart
data={punkte}
margin={MARGIN.standard}
barCategoryGap={BALKEN.kategorieAbstand}
onMouseMove={(zustand) =>
setAktiv(typeof zustand?.activeTooltipIndex === "number" ? zustand.activeTooltipIndex : null)
}
onMouseLeave={() => setAktiv(null)}
>
<CartesianGrid stroke={CHART.grid} vertical={false} />
<XAxis dataKey="label" interval={intervall} {...achseX} />
<YAxis
tickFormatter={formatAchse ?? formatWert}
allowDecimals={!nurGanzzahlen}
{...(raster ? { domain: raster.domain, ticks: raster.ticks } : {})}
{...achseY}
/>
<Tooltip
cursor={{ fill: "rgba(22,22,22,0.04)" }}
content={(props) => (
<ChartTooltip {...props} formatWert={formatWert} labelPrefix={labelPrefix} />
)}
/>
<Bar
dataKey="value"
name="Wert"
fill={farbe}
maxBarSize={BALKEN.maxBreite}
radius={[BALKEN.radius, BALKEN.radius, 0, 0]}
>
{punkte.map((_, index) => (
<Cell
key={index}
fill={
farbenProBalken ? farbenProBalken[index % farbenProBalken.length] : farbe
}
opacity={aktiv !== null && aktiv !== index ? 0.45 : 1}
/>
))}
</Bar>
</BarChart>
</ResponsiveContainer>
</div>
);
}
@@ -0,0 +1,21 @@
import React from "react";
import { FeatherBarChart2 } from "@subframe/core";
/** Leerzustand — wichtiger als er aussieht: Filter können jedes Chart leeren. */
export function ChartLeer({
text = "Keine Daten im gewählten Zeitraum",
hoehe = 220,
}: {
text?: string;
hoehe?: number;
}) {
return (
<div
className="flex flex-col items-center justify-center gap-2 rounded-md border border-dashed border-border-default"
style={{ height: hoehe }}
>
<FeatherBarChart2 className="text-[20px] text-text-neutral-subtle" />
<span className="text-[13px] text-text-neutral-tertiary">{text}</span>
</div>
);
}
@@ -0,0 +1,64 @@
"use client";
import React from "react";
/**
* Legende als eigene Komponente statt Recharts-Legend:
* Recharts platziert die Legende im SVG und kostet damit Chartfläche.
* Carbon setzt sie über den Chart, linksbündig, 12 px, 12 px Marker.
*/
export function ChartLegende({
eintraege,
/** Ausgeblendete Reihen erscheinen ausgegraut — Klick schaltet um. */
inaktiv = [],
onToggle,
}: {
eintraege: { name: string; farbe: string; wert?: string; gestrichelt?: boolean }[];
inaktiv?: string[];
onToggle?: (name: string) => void;
}) {
return (
<div className="flex flex-wrap items-center gap-x-4 gap-y-1.5">
{eintraege.map((eintrag) => {
const aus = inaktiv.includes(eintrag.name);
const Inhalt = (
<>
<span
className="h-2.5 w-2.5 flex-none rounded-sm"
style={{
background: eintrag.gestrichelt ? "transparent" : eintrag.farbe,
border: eintrag.gestrichelt ? `2px dashed ${eintrag.farbe}` : undefined,
opacity: aus ? 0.35 : 1,
}}
/>
<span
className="text-[12px]"
style={{ color: aus ? "#a8a8a8" : "#525252" }}
>
{eintrag.name}
</span>
{eintrag.wert ? (
<span className="text-[12px] font-semibold tabular-nums text-text-neutral-primary">
{eintrag.wert}
</span>
) : null}
</>
);
return onToggle ? (
<button
key={eintrag.name}
onClick={() => onToggle(eintrag.name)}
className="flex items-center gap-1.5 rounded px-1 py-0.5 hover:bg-neutral-50"
>
{Inhalt}
</button>
) : (
<span key={eintrag.name} className="flex items-center gap-1.5">
{Inhalt}
</span>
);
})}
</div>
);
}
@@ -0,0 +1,77 @@
"use client";
import React from "react";
import { CHART } from "../../utils/chartTheme";
/**
* Einheitlicher Tooltip für alle Charts.
*
* Carbon-Vorgabe: dunkle Fläche (#393939), heller Text, 12 px Label,
* kein Rahmen, kein Doppelpunkt zwischen Name und Wert.
* Ein gemeinsamer Tooltip verhindert, dass jedes Chart eigene Regeln erfindet.
*
* Die Props sind bewusst weit typisiert: Recharts reicht sein internes
* Payload-Format durch, das je nach Chart-Typ leicht abweicht.
*/
interface TooltipPayload {
name?: unknown;
value?: unknown;
color?: string;
dataKey?: unknown;
}
export function ChartTooltip({
active,
label,
payload,
formatWert,
labelPrefix,
}: {
active?: boolean;
label?: unknown;
payload?: readonly TooltipPayload[];
formatWert: (wert: number) => string;
labelPrefix?: string;
}) {
if (!active || !payload?.length) return null;
const reihen = payload
.filter((eintrag) => typeof eintrag.value === "number")
.map((eintrag) => ({
name: String(eintrag.name ?? eintrag.dataKey ?? ""),
value: eintrag.value as number,
color: eintrag.color,
}));
if (!reihen.length) return null;
const labelText = label === undefined || label === null ? "" : String(label);
return (
<div
className="pointer-events-none rounded-md px-3 py-2 shadow-lg"
style={{ background: CHART.tooltipBg, color: CHART.tooltipFg }}
>
{labelText ? (
<div className="mb-1 text-[12px] opacity-80">
{labelPrefix ? `${labelPrefix} ` : ""}
{labelText}
</div>
) : null}
<div className="flex flex-col gap-0.5">
{reihen.map((reihe) => (
<div key={reihe.name} className="flex items-center gap-2 text-[13px]">
{reihe.color ? (
<span
className="h-2.5 w-2.5 flex-none rounded-sm"
style={{ background: reihe.color }}
/>
) : null}
<span className="opacity-80">{reihe.name}</span>
<span className="ml-auto font-semibold tabular-nums">{formatWert(reihe.value)}</span>
</div>
))}
</div>
</div>
);
}
@@ -0,0 +1,118 @@
"use client";
import React from "react";
import { Cell, Pie, PieChart, ResponsiveContainer, Tooltip } from "recharts";
import { ChartTooltip } from "./ChartTooltip";
import { ChartLeer } from "./ChartLeer";
import { DONUT, farbeFuer, gruppiereRest } from "../../utils/chartTheme";
/**
* Donut für Anteile.
*
* Regeln aus der Planung + Carbon:
* - maximal 5 Segmente, Rest als "Sonstige" (gruppiereRest)
* - größtes Segment startet oben, dann im Uhrzeigersinn absteigend
* - Gesamtwert steht in der Mitte, sonst muss man die Segmente addieren
* - Legende rechts mit Wert, einzeilig — nicht im Chart
* - Klick auf einen Legendeneintrag hebt das Segment hervor
*/
export function Donut({
daten,
formatWert,
hoehe = 220,
mitteLabel = "Gesamt",
maxSegmente,
/**
* Format der Ringmitte. Getrennt vom Legendenformat, weil die Mitte eine
* Schlagzahl ist: Steht dieselbe Summe als Kennzahl auf der Seite, muss sie
* gleich geschrieben sein — "285,3 T€" neben "285.318 €" liest sich wie
* zwei verschiedene Zahlen.
*/
formatMitte,
}: {
daten: { name: string; value: number }[];
formatWert: (wert: number) => string;
hoehe?: number;
mitteLabel?: string;
maxSegmente?: number;
formatMitte?: (wert: number) => string;
}) {
const [aktiv, setAktiv] = React.useState<string | null>(null);
const segmente = gruppiereRest(daten.filter((d) => d.value > 0), maxSegmente);
if (!segmente.length) return <ChartLeer hoehe={hoehe} />;
const gesamt = segmente.reduce((summe, s) => summe + s.value, 0);
return (
<div className="grid grid-cols-[168px_minmax(0,1fr)] items-center gap-5">
<div className="relative" style={{ height: hoehe }}>
<ResponsiveContainer width="100%" height="100%">
<PieChart>
<Pie
data={segmente}
dataKey="value"
nameKey="name"
innerRadius={DONUT.innenRadius}
outerRadius={DONUT.aussenRadius}
paddingAngle={DONUT.segmentAbstand}
startAngle={90}
endAngle={-270}
stroke="#ffffff"
strokeWidth={2}
isAnimationActive={false}
>
{segmente.map((segment, index) => (
<Cell
key={segment.name}
fill={farbeFuer(segment.name, index)}
opacity={aktiv && aktiv !== segment.name ? 0.35 : 1}
/>
))}
</Pie>
<Tooltip content={(props) => <ChartTooltip {...props} formatWert={formatWert} />} />
</PieChart>
</ResponsiveContainer>
<div className="pointer-events-none absolute inset-0 flex flex-col items-center justify-center">
<span className="text-[11px] uppercase tracking-[0.06em] text-text-neutral-tertiary">
{mitteLabel}
</span>
<span className="text-[15px] font-semibold tabular-nums text-text-neutral-primary">
{(formatMitte ?? formatWert)(gesamt)}
</span>
</div>
</div>
<ul className="flex flex-col gap-1.5">
{segmente.map((segment, index) => {
const anteil = gesamt > 0 ? (segment.value / gesamt) * 100 : 0;
return (
<li key={segment.name}>
<button
onMouseEnter={() => setAktiv(segment.name)}
onMouseLeave={() => setAktiv(null)}
onClick={() => setAktiv((wert) => (wert === segment.name ? null : segment.name))}
className="flex w-full items-start gap-2 rounded-sm px-1 py-1 text-left hover:bg-neutral-50"
>
<span
className="mt-1 h-2.5 w-2.5 flex-none rounded-sm"
style={{ background: farbeFuer(segment.name, index) }}
/>
<span className="min-w-0 grow text-[12px] leading-snug text-text-neutral-secondary">
{segment.name}
</span>
<span className="flex-none whitespace-nowrap text-[12px] tabular-nums text-text-neutral-primary">
<span className="font-semibold">{formatWert(segment.value)}</span>
<span className="ml-1.5 text-text-neutral-tertiary">
{anteil.toFixed(0)} %
</span>
</span>
</button>
</li>
);
})}
</ul>
</div>
);
}
@@ -0,0 +1,47 @@
"use client";
import React from "react";
/**
* Miniaturverlauf in KPI-Karten.
* Bewusst als handgeschriebenes SVG: Recharts würde für 8 Punkte
* einen ResponsiveContainer samt Resize-Beobachter aufziehen.
*/
export function Sparkline({ werte, farbe }: { werte: number[]; farbe: string }) {
if (werte.length < 2) return null;
const max = Math.max(...werte);
const min = Math.min(...werte);
const spanne = Math.max(1, max - min);
const punkte = werte
.map((wert, index) => {
const x = (index / (werte.length - 1)) * 100;
const y = 28 - ((wert - min) / spanne) * 24;
return `${x.toFixed(2)},${y.toFixed(2)}`;
})
.join(" ");
const id = `spark-${farbe.replace("#", "")}`;
return (
<svg viewBox="0 0 100 32" className="h-full w-full" preserveAspectRatio="none" aria-hidden="true">
<defs>
<linearGradient id={id} x1="0" y1="0" x2="0" y2="1">
<stop offset="0%" stopColor={farbe} stopOpacity="0.22" />
<stop offset="100%" stopColor={farbe} stopOpacity="0" />
</linearGradient>
</defs>
<polygon points={`0,32 ${punkte} 100,32`} fill={`url(#${id})`} />
<polyline
points={punkte}
fill="none"
stroke={farbe}
strokeWidth="1.5"
strokeLinejoin="round"
strokeLinecap="round"
vectorEffect="non-scaling-stroke"
/>
</svg>
);
}
@@ -0,0 +1,85 @@
"use client";
import React from "react";
import { KATEGORIE_FARBEN } from "../../utils/chartTheme";
import { ChartLeer } from "./ChartLeer";
/**
* Vertriebstrichter.
*
* Zeigt je Stufe die absolute Zahl, die Balkenlänge als Anteil an der ersten
* Stufe und die Übergangsquote von der vorherigen Stufe. Genau die
* Übergangsquote ist die Zahl, nach der Betriebe ihren Vertrieb steuern:
* Sie zeigt, wo Vorgänge verloren gehen.
*
* Einfarbig: Die Stufen sind eine Reihenfolge, keine unabhängigen Kategorien —
* DESIGN-SYSTEM.md §1 „Rangfolgen einfarbig". Eine Farbabstufung würde nur
* kodieren, was die Reihenfolge ohnehin sagt.
*
* Die Balken sind zentriert, nicht linksbündig: So liest man die Verjüngung als
* Trichterform, ohne die gemeinsame Skala aufzugeben. Ein echtes Funnel-Chart
* mit breitenkodierten Segmenten kennt Carbon bewusst nicht — es verzerrt.
*/
export function Trichter({
stufen,
formatWert,
}: {
stufen: { name: string; value: number }[];
formatWert: (wert: number) => string;
}) {
const [aktiv, setAktiv] = React.useState<number | null>(null);
if (!stufen.length || stufen[0].value === 0) return <ChartLeer hoehe={220} />;
const start = stufen[0].value;
return (
<ol className="flex flex-col gap-2">
{stufen.map((stufe, index) => {
const anteilGesamt = (stufe.value / start) * 100;
const vorher = index > 0 ? stufen[index - 1].value : null;
const uebergang = vorher && vorher > 0 ? (stufe.value / vorher) * 100 : null;
const hervorgehoben = aktiv === index;
return (
<li
key={stufe.name}
onMouseEnter={() => setAktiv(index)}
onMouseLeave={() => setAktiv(null)}
className="grid grid-cols-[96px_minmax(0,1fr)_52px_44px] items-center gap-2"
>
<span className="truncate text-[12px] text-text-neutral-secondary">{stufe.name}</span>
<span className="flex h-6 w-full items-center justify-center rounded-sm bg-neutral-100">
<span
className="block h-full rounded-sm transition-[width,opacity] duration-300"
style={{
width: `${Math.max(3, anteilGesamt)}%`,
background: KATEGORIE_FARBEN[0],
opacity: aktiv !== null && !hervorgehoben ? 0.45 : 1,
}}
/>
</span>
<span className="text-right text-[12px] font-semibold tabular-nums text-text-neutral-primary">
{formatWert(stufe.value)}
</span>
<span
className={`text-right text-[12px] tabular-nums ${
hervorgehoben ? "font-semibold text-text-neutral-primary" : "text-text-neutral-tertiary"
}`}
title={uebergang !== null ? "Übergang von der vorherigen Stufe" : "Startwert des Trichters"}
>
{uebergang !== null ? `${uebergang.toFixed(0)} %` : "—"}
</span>
</li>
);
})}
<li className="mt-1 flex items-center justify-end gap-1 border-t border-solid border-border-default pt-2 text-[11px] text-text-neutral-tertiary">
Rechte Spalte: Übergang von der vorherigen Stufe
</li>
</ol>
);
}