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,107 @@
"use client";
import React from "react";
import {
FeatherAlertTriangle,
FeatherArrowRight,
FeatherCheckCircle,
FeatherInfo,
} from "@subframe/core";
import { STATUS_FARBEN } from "../../utils/chartTheme";
import { formatEuro } from "../../utils/formatters";
import { useToast } from "../../context/ToastContext";
import type { AlertEintrag } from "../../data/calculations";
/**
* Handlungsbedarf-Liste (COMP-08).
*
* Jede Zeile nennt drei Dinge: was los ist, um wie viel Geld es geht und was
* zu tun ist. Ohne den Betrag lassen sich die Zeilen nicht gegeneinander
* abwägen, ohne die Handlung ist die Liste ein Bericht statt einer Arbeitsliste.
* Der Absprung in die jeweilige Arbeitsliste ist im Prototyp eine Attrappe.
*/
export function AlertList({
eintraege,
leerText = "Keine offenen Punkte",
/** Zwei Spalten, wenn die Karte über die volle Seitenbreite läuft. */
spalten = 1,
}: {
eintraege: AlertEintrag[];
leerText?: string;
spalten?: 1 | 2;
}) {
const { zeigeToast } = useToast();
const rang = { kritisch: 0, warnung: 1, hinweis: 2 } as const;
const sortiert = [...eintraege].sort((a, b) => rang[a.art] - rang[b.art]);
if (!sortiert.length) {
return (
<div className="flex h-full min-h-[180px] flex-col items-center justify-center gap-2 text-center">
<FeatherCheckCircle className="text-[22px]" style={{ color: STATUS_FARBEN.positiv }} />
<span className="text-[13px] text-text-neutral-tertiary">{leerText}</span>
</div>
);
}
return (
// Container-Query statt Viewport: dieselbe Liste steht mal über die volle
// Seitenbreite und mal in einer Drittelkarte. Der Viewport weiß davon nichts.
<ul
className={`@container ${
spalten === 2 ? "grid grid-cols-1 gap-x-8 xl:grid-cols-2" : "flex flex-col"
}`}
>
{sortiert.map((eintrag) => {
const farbe =
eintrag.art === "kritisch"
? STATUS_FARBEN.negativ
: eintrag.art === "warnung"
? STATUS_FARBEN.warnung
: STATUS_FARBEN.info;
return (
<li key={eintrag.id}>
<button
onClick={() =>
zeigeToast(eintrag.aktion, `${eintrag.text} — Absprung folgt in der Umsetzung`)
}
className="group flex w-full items-center gap-3 border-b border-solid border-border-default py-3 text-left last:border-b-0 hover:bg-neutral-50"
>
<span className="flex-none" style={{ color: farbe }}>
{eintrag.art === "hinweis" ? (
<FeatherInfo className="text-[16px]" />
) : (
<FeatherAlertTriangle className="text-[16px]" />
)}
</span>
<span className="flex min-w-0 grow flex-col">
<span className="text-[13px] font-medium leading-snug text-text-neutral-primary">
{eintrag.text}
</span>
<span className="text-[12px] leading-snug text-text-neutral-tertiary">
{eintrag.detail}
</span>
</span>
{eintrag.betrag !== undefined ? (
<span className="flex-none whitespace-nowrap text-[14px] font-semibold tabular-nums text-text-neutral-primary">
{formatEuro(eintrag.betrag)}
</span>
) : null}
{/* Schmale Karte: nur der Pfeil, die Handlung steht im Tooltip. */}
<span
title={eintrag.aktion}
className="flex flex-none items-center justify-end gap-1 whitespace-nowrap text-[12px] font-medium text-text-neutral-tertiary group-hover:text-text-neutral-primary @md:w-[150px]"
>
<span className="hidden @md:inline">{eintrag.aktion}</span>
<FeatherArrowRight className="text-[13px]" />
</span>
</button>
</li>
);
})}
</ul>
);
}
@@ -0,0 +1,144 @@
"use client";
import React from "react";
import {
FeatherDownload,
FeatherEyeOff,
FeatherInfo,
FeatherMoreHorizontal,
} from "@subframe/core";
import { useWidgets } from "../../context/WidgetContext";
import { useToast } from "../../context/ToastContext";
/**
* Rahmen für jede Visualisierung (COMP-09).
*
* Enthält die einzige "echte" Interaktionslogik des Prototyps:
* Über das ⋯-Menü lässt sich die Karte ausblenden; sie taucht dann in der
* Filterleiste zum Wiedereinblenden auf. Der Zustand ist persistiert.
*/
export function ChartCard({
id,
titel,
untertitel,
hinweis,
aktion,
legende,
children,
className = "",
}: {
/** Stabile ID — Schlüssel für Ausblenden/Einblenden. */
id: string;
titel: string;
untertitel?: string;
/** Erklärt die Kennzahl; erscheint als Tooltip am (i). */
hinweis?: string;
aktion?: React.ReactNode;
legende?: React.ReactNode;
children: React.ReactNode;
className?: string;
}) {
const { istSichtbar, verstecke } = useWidgets();
const { zeigeToast } = useToast();
const [menuOffen, setMenuOffen] = React.useState(false);
const menu = React.useRef<HTMLDivElement>(null);
const ausloeser = React.useRef<HTMLButtonElement>(null);
React.useEffect(() => {
if (!menuOffen) return;
const schliesse = (event: MouseEvent) => {
if (!menu.current?.contains(event.target as Node)) setMenuOffen(false);
};
// Escape schliesst und gibt den Fokus an den Ausloeser zurueck — sonst
// landet die Tastaturbedienung nach dem Schliessen am Seitenanfang.
const taste = (event: KeyboardEvent) => {
if (event.key === "Escape") {
setMenuOffen(false);
ausloeser.current?.focus();
}
};
document.addEventListener("mousedown", schliesse);
document.addEventListener("keydown", taste);
return () => {
document.removeEventListener("mousedown", schliesse);
document.removeEventListener("keydown", taste);
};
}, [menuOffen]);
if (!istSichtbar(id)) return null;
return (
<section
className={`flex flex-col overflow-hidden rounded-lg border border-solid border-border-default bg-white shadow-sm ${className}`}
>
<header className="flex flex-none items-start justify-between gap-3 px-4 pb-3 pt-4">
<div className="flex min-w-0 flex-col">
<div className="flex items-center gap-1.5">
<h2 className="truncate text-[14px] font-semibold leading-tight text-text-neutral-primary">
{titel}
</h2>
{hinweis ? (
<span
title={hinweis}
className="flex h-4 w-4 flex-none cursor-help items-center justify-center text-text-neutral-subtle hover:text-text-neutral-secondary"
>
<FeatherInfo className="text-[13px]" />
</span>
) : null}
</div>
{untertitel ? (
<p className="line-clamp-2 text-[12px] leading-snug text-text-neutral-tertiary">
{untertitel}
</p>
) : null}
</div>
<div className="dv-no-print relative flex flex-none items-center gap-1" ref={menu}>
{aktion}
<button
ref={ausloeser}
onClick={() => setMenuOffen((wert) => !wert)}
aria-label={`Optionen für ${titel}`}
aria-haspopup="menu"
aria-expanded={menuOffen}
className="flex h-8 w-8 items-center justify-center rounded-md text-text-neutral-tertiary hover:bg-neutral-100 hover:text-text-neutral-primary"
>
<FeatherMoreHorizontal className="text-[16px]" />
</button>
{menuOffen ? (
<div
role="menu"
className="absolute right-0 top-9 z-40 flex w-52 flex-col rounded-lg border border-solid border-border-default bg-white py-1 shadow-lg"
>
<button
onClick={() => {
verstecke(id, titel);
setMenuOffen(false);
}}
className="flex items-center gap-2 px-3 py-2 text-left text-[13px] text-text-neutral-primary hover:bg-neutral-50"
>
<FeatherEyeOff className="text-[14px] text-text-neutral-tertiary" />
Widget ausblenden
</button>
<button
onClick={() => {
zeigeToast("Als Bild vorgemerkt", `${titel} — Export folgt in der Umsetzung`);
setMenuOffen(false);
}}
className="flex items-center gap-2 px-3 py-2 text-left text-[13px] text-text-neutral-primary hover:bg-neutral-50"
>
<FeatherDownload className="text-[14px] text-text-neutral-tertiary" />
Als Bild exportieren
</button>
</div>
) : null}
</div>
</header>
{legende ? <div className="flex-none px-4 pb-2">{legende}</div> : null}
<div className="min-h-0 grow px-4 pb-4">{children}</div>
</section>
);
}
@@ -0,0 +1,139 @@
"use client";
import React from "react";
import { FeatherArrowDownRight, FeatherArrowUpRight, FeatherMinus } from "@subframe/core";
import { FeatherIcon } from "../layout/FeatherIcon";
import { Sparkline } from "../charts/Sparkline";
import { CHART, STATUS_FARBEN } from "../../utils/chartTheme";
/** Zeitbezug einer Kennzahl — siehe docs/KPI-KATALOG.md. */
export type Bezug = "zeitraum" | "stichtag" | "gesamt";
const BEZUG_LABEL: Record<Bezug, string> = {
zeitraum: "im gewählten Zeitraum",
stichtag: "zum Stichtag",
gesamt: "über alle Zeiträume",
};
/**
* KPI-Karte nach UI_UX_GUIDELINES.md, Abschnitt 4:
* Label oben links · Icon oben rechts · Wert · Zusatz · Fußzeile.
*
* Alle Karten einer Reihe haben dieselbe Anatomie — auch die ohne Trend.
* Wo kein Vorperiodenvergleich möglich ist (stichtagsbezogene Kennzahlen),
* trägt die Fußzeile den Zeitbezug. Ohne das steht in einer Reihe eine
* Karte mit Trendzeile neben vier Karten mit leerem Fuß, und das Auge
* sucht eine Regel, die es nicht gibt.
*
* Der Trend vergleicht immer mit der gleich langen Vorperiode
* (30 Tage gegen die 30 Tage davor) — nicht mit dem Vorjahr.
*/
export function KPICard({
label,
wert,
zusatz,
trend,
trendLabel = "Vorperiode",
bezug = "zeitraum",
icon,
verlauf,
akzent = "neutral",
/** Bei "positiv" ist ein steigender Wert gut, bei "negativ" schlecht. */
richtungGut = "positiv",
}: {
label: string;
wert: string;
zusatz?: string;
trend?: { wert: number; richtung: "up" | "down" | "flat" };
trendLabel?: string;
bezug?: Bezug;
icon: string;
verlauf?: number[];
/**
* Färbt das Icon. Nur setzen, wenn die Farbe aus einem Schwellenvergleich
* kommt — ein dekorativ grünes Icon behauptet "gut", ohne es zu belegen
* (docs/DESIGN-SYSTEM.md §1: Statusfarben nur für Aussagen).
*/
akzent?: "neutral" | "positiv" | "warnung" | "negativ" | "info";
richtungGut?: "positiv" | "negativ";
}) {
const gut =
trend?.richtung === "flat"
? null
: richtungGut === "positiv"
? trend?.richtung === "up"
: trend?.richtung === "down";
const trendFarbe =
gut === null ? STATUS_FARBEN.neutral : gut ? STATUS_FARBEN.positiv : STATUS_FARBEN.negativ;
const akzentFarbe = {
neutral: CHART.textSekundaer,
positiv: STATUS_FARBEN.positiv,
warnung: STATUS_FARBEN.warnung,
negativ: STATUS_FARBEN.negativ,
info: STATUS_FARBEN.info,
}[akzent];
return (
<article className="flex min-h-[136px] flex-col rounded-lg border border-solid border-border-default bg-white p-4 shadow-sm transition-shadow duration-200 hover:shadow-md">
<div className="flex items-start justify-between gap-2">
<span className="text-[12px] font-medium leading-tight text-text-neutral-tertiary">
{label}
</span>
<span
className="flex h-8 w-8 flex-none items-center justify-center rounded-md bg-neutral-50"
style={{ color: akzentFarbe }}
>
<FeatherIcon name={icon} className="text-[15px]" />
</span>
</div>
<div className="mt-3 flex flex-col gap-1">
<span className="text-[28px] font-semibold leading-none tracking-[-0.02em] text-text-neutral-primary">
{wert}
</span>
{zusatz ? (
<span className="text-[12px] leading-snug text-text-neutral-tertiary">{zusatz}</span>
) : null}
</div>
{/* Fußzeile: immer vorhanden, damit die Reihe eine gemeinsame Grundlinie hat. */}
<div className="mt-auto flex items-end justify-between gap-3 pt-3">
{trend ? (
<span
className="flex min-w-0 items-center gap-1 whitespace-nowrap text-[12px] font-medium"
style={{ color: trendFarbe }}
>
{trend.richtung === "up" ? (
<FeatherArrowUpRight className="text-[13px] flex-none" />
) : trend.richtung === "down" ? (
<FeatherArrowDownRight className="text-[13px] flex-none" />
) : (
<FeatherMinus className="text-[13px] flex-none" />
)}
{trend.richtung === "flat"
? "unverändert"
: `${trend.wert.toFixed(1).replace(".", ",")} %`}
<span className="hidden truncate font-normal text-text-neutral-tertiary xl:inline">
{trendLabel}
</span>
</span>
) : (
<span className="text-[11px] leading-tight text-text-neutral-tertiary">
{BEZUG_LABEL[bezug]}
</span>
)}
{verlauf && verlauf.length > 1 ? (
<span className="h-8 w-16 flex-none">
{/* Die Kurve trägt dieselbe Aussage wie der Pfeil daneben und
deshalb auch dieselbe Farbe — sonst zeigt die Karte zwei
widersprüchliche Signale. */}
<Sparkline werte={verlauf} farbe={trend ? trendFarbe : CHART.achse} />
</span>
) : null}
</div>
</article>
);
}
@@ -0,0 +1,38 @@
import React from "react";
/**
* Kompakte Zusatzkennzahlen unter einem Chart —
* beantwortet "und was heißt das jetzt?" ohne eigene Karte.
*/
export function StatZeile({
eintraege,
/**
* Spalten auf breiten Schirmen. In einer Drittelkarte brechen vier Spalten
* mitten im Betrag um ("1,22 Mio." / "€") — dort gehoeren zwei hin.
*/
spalten = 4,
}: {
eintraege: { label: string; wert: string; hinweis?: string }[];
spalten?: 2 | 3 | 4;
}) {
const raster = { 2: "md:grid-cols-2", 3: "md:grid-cols-3", 4: "md:grid-cols-4" }[spalten];
return (
<div
className={`grid grid-cols-2 gap-x-6 gap-y-3 border-t border-solid border-border-default pt-3 ${raster}`}
>
{eintraege.map((eintrag) => (
<div key={eintrag.label} className="flex flex-col gap-0.5">
<span className="text-[11px] uppercase tracking-[0.06em] text-text-neutral-tertiary">
{eintrag.label}
</span>
<span className="text-[14px] font-semibold tabular-nums text-text-neutral-primary">
{eintrag.wert}
</span>
{eintrag.hinweis ? (
<span className="text-[11px] text-text-neutral-tertiary">{eintrag.hinweis}</span>
) : null}
</div>
))}
</div>
);
}
@@ -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>
);
}
@@ -0,0 +1,203 @@
"use client";
import React from "react";
import { FeatherEye, FeatherRotateCcw, FeatherX } from "@subframe/core";
import { MehrfachAuswahl } from "./MehrfachAuswahl";
import { useFilter, type MehrfachFeld } from "../../context/FilterContext";
import { useWidgets } from "../../context/WidgetContext";
import { DATENSATZ } from "../../data/seed";
import { FILTER_RELEVANZ, type SeitenId } from "../../data/filtering";
import {
AUFTRAG_STATUS_LABEL,
GEWERKE,
ZEITRAUM_LABEL,
type AuftragStatus,
type ZeitraumPreset,
} from "../../data/types";
const ZEITRAEUME: ZeitraumPreset[] = ["heute", "7_tage", "30_tage", "quartal", "jahr", "alles"];
/**
* Filterleiste über dem Seiteninhalt.
*
* Zeigt nur die Filter, die auf der jeweiligen Seite etwas bewirken
* (FILTER_RELEVANZ) — ein Auftragsstatus-Filter auf der Finanzseite würde
* sonst wirkungslos wirken und Vertrauen kosten.
* Aktive Einschränkungen erscheinen darunter als entfernbare Chips (FILT-06).
*/
export function AnalyticsToolbar({ seite }: { seite: SeitenId }) {
const { filter, setFilter, toggleWert, leereFeld, zuruecksetzen } = useFilter();
const { versteckt, titel, zeige, zeigeAlle } = useWidgets();
const erlaubt = new Set(FILTER_RELEVANZ[seite]);
const quellen = React.useMemo(
() => [...new Set(DATENSATZ.kunden.map((k) => k.quelle))].sort(),
[]
);
const regionen = React.useMemo(
() => [...new Set(DATENSATZ.kunden.map((k) => k.region))].sort(),
[]
);
const monteure = React.useMemo(
() =>
DATENSATZ.mitarbeiter
.filter((m) => m.rolle === "Monteur" || m.rolle === "Meister")
.map((m) => ({ wert: m.id, label: m.name, zusatz: m.gewerk })),
[]
);
const chips: { feld: MehrfachFeld; wert: string; label: string }[] = [];
if (erlaubt.has("gewerke"))
chips.push(...filter.gewerke.map((g) => ({ feld: "gewerke" as const, wert: g, label: g })));
if (erlaubt.has("auftragStatus"))
chips.push(
...filter.auftragStatus.map((s) => ({
feld: "auftragStatus" as const,
wert: s,
label: AUFTRAG_STATUS_LABEL[s],
}))
);
if (erlaubt.has("kundenQuellen"))
chips.push(
...filter.kundenQuellen.map((q) => ({ feld: "kundenQuellen" as const, wert: q, label: q }))
);
if (erlaubt.has("regionen"))
chips.push(...filter.regionen.map((r) => ({ feld: "regionen" as const, wert: r, label: r })));
if (erlaubt.has("mitarbeiterIds"))
chips.push(
...filter.mitarbeiterIds.map((id) => ({
feld: "mitarbeiterIds" as const,
wert: id,
label: DATENSATZ.mitarbeiter.find((m) => m.id === id)?.name ?? id,
}))
);
return (
<div className="dv-no-print sticky top-14 z-20 flex flex-col gap-2 border-b border-solid border-border-default bg-neutral-50/95 px-6 py-3 backdrop-blur">
<div className="flex flex-wrap items-center gap-2">
{/* Zeitraum als Segment-Control: eine Auswahl, immer sichtbar. */}
<div className="flex items-center rounded-md border border-solid border-border-default bg-white p-0.5">
{ZEITRAEUME.map((preset) => (
<button
key={preset}
onClick={() => setFilter((aktuell) => ({ ...aktuell, zeitraum: preset }))}
aria-pressed={filter.zeitraum === preset}
className={`rounded px-2.5 py-1 text-[13px] font-medium transition-colors ${
filter.zeitraum === preset
? "bg-neutral-800 text-white"
: "text-text-neutral-secondary hover:bg-neutral-100"
}`}
>
{ZEITRAUM_LABEL[preset]}
</button>
))}
</div>
<span className="mx-1 h-6 w-px bg-border-default" />
{erlaubt.has("gewerke") ? (
<MehrfachAuswahl
label="Gewerk"
optionen={GEWERKE.map((g) => ({ wert: g, label: g }))}
ausgewaehlt={filter.gewerke}
onToggle={(wert) => toggleWert("gewerke", wert)}
onLeeren={() => leereFeld("gewerke")}
/>
) : null}
{erlaubt.has("auftragStatus") ? (
<MehrfachAuswahl
label="Status"
optionen={(Object.keys(AUFTRAG_STATUS_LABEL) as AuftragStatus[]).map((s) => ({
wert: s,
label: AUFTRAG_STATUS_LABEL[s],
}))}
ausgewaehlt={filter.auftragStatus}
onToggle={(wert) => toggleWert("auftragStatus", wert)}
onLeeren={() => leereFeld("auftragStatus")}
/>
) : null}
{erlaubt.has("kundenQuellen") ? (
<MehrfachAuswahl
label="Quelle"
optionen={quellen.map((q) => ({ wert: q, label: q }))}
ausgewaehlt={filter.kundenQuellen}
onToggle={(wert) => toggleWert("kundenQuellen", wert)}
onLeeren={() => leereFeld("kundenQuellen")}
/>
) : null}
{erlaubt.has("regionen") ? (
<MehrfachAuswahl
label="Region"
optionen={regionen.map((r) => ({ wert: r, label: r }))}
ausgewaehlt={filter.regionen}
onToggle={(wert) => toggleWert("regionen", wert)}
onLeeren={() => leereFeld("regionen")}
/>
) : null}
{erlaubt.has("mitarbeiterIds") ? (
<MehrfachAuswahl
label="Mitarbeiter"
optionen={monteure}
ausgewaehlt={filter.mitarbeiterIds}
onToggle={(wert) => toggleWert("mitarbeiterIds", wert)}
onLeeren={() => leereFeld("mitarbeiterIds")}
/>
) : null}
{chips.length ? (
<button
onClick={zuruecksetzen}
className="ml-auto flex h-8 items-center gap-1.5 rounded-md px-2.5 text-[13px] font-medium text-text-neutral-tertiary hover:bg-neutral-100 hover:text-text-neutral-primary"
>
<FeatherRotateCcw className="text-[14px]" />
Filter zurücksetzen
</button>
) : null}
</div>
{chips.length ? (
<div className="flex flex-wrap items-center gap-1.5">
{chips.map((chip) => (
<button
key={`${chip.feld}-${chip.wert}`}
onClick={() => toggleWert(chip.feld, chip.wert)}
className="group flex items-center gap-1.5 rounded-full border border-solid border-border-default bg-white py-1 pl-2.5 pr-2 text-[12px] font-medium text-text-neutral-secondary hover:border-border-strong"
>
{chip.label}
<FeatherX className="text-[12px] text-text-neutral-tertiary group-hover:text-text-neutral-primary" />
</button>
))}
</div>
) : null}
{versteckt.length ? (
<div className="flex flex-wrap items-center gap-1.5 rounded-md border border-dashed border-border-strong bg-white px-3 py-2">
<span className="flex items-center gap-1.5 text-[12px] font-medium text-text-neutral-tertiary">
<FeatherEye className="text-[13px]" />
{versteckt.length} ausgeblendet:
</span>
{versteckt.map((id) => (
<button
key={id}
onClick={() => zeige(id)}
className="rounded-full border border-solid border-border-default px-2.5 py-1 text-[12px] font-medium text-text-neutral-secondary hover:bg-neutral-50"
>
{titel[id] ?? id} einblenden
</button>
))}
<button
onClick={zeigeAlle}
className="ml-auto text-[12px] font-semibold text-text-neutral-primary underline underline-offset-2"
>
Alle einblenden
</button>
</div>
) : null}
</div>
);
}
@@ -0,0 +1,141 @@
"use client";
import React from "react";
import { FeatherCheck, FeatherChevronDown, FeatherSearch } from "@subframe/core";
/**
* Mehrfachauswahl mit Suche (COMP-06).
* Bewusst schlank gehalten: ein Button, ein Panel, Klick außerhalb schließt.
*/
export function MehrfachAuswahl({
label,
optionen,
ausgewaehlt,
onToggle,
onLeeren,
suchbarAb = 8,
}: {
label: string;
optionen: { wert: string; label: string; zusatz?: string }[];
ausgewaehlt: string[];
onToggle: (wert: string) => void;
onLeeren: () => void;
/** Ab wie vielen Optionen ein Suchfeld eingeblendet wird. */
suchbarAb?: number;
}) {
const [offen, setOffen] = React.useState(false);
const [suche, setSuche] = React.useState("");
const wrapper = React.useRef<HTMLDivElement>(null);
const ausloeser = React.useRef<HTMLButtonElement>(null);
React.useEffect(() => {
if (!offen) return;
const schliesse = (event: MouseEvent) => {
if (!wrapper.current?.contains(event.target as Node)) setOffen(false);
};
const taste = (event: KeyboardEvent) => {
if (event.key === "Escape") {
setOffen(false);
ausloeser.current?.focus();
}
};
document.addEventListener("mousedown", schliesse);
document.addEventListener("keydown", taste);
return () => {
document.removeEventListener("mousedown", schliesse);
document.removeEventListener("keydown", taste);
};
}, [offen]);
const gefiltert = optionen.filter((o) =>
o.label.toLowerCase().includes(suche.toLowerCase())
);
return (
<div ref={wrapper} className="relative">
<button
ref={ausloeser}
onClick={() => setOffen((wert) => !wert)}
aria-expanded={offen}
aria-haspopup="listbox"
className={`flex h-8 items-center gap-1.5 rounded-md border border-solid px-2.5 text-[13px] font-medium transition-colors ${
ausgewaehlt.length
? "border-neutral-800 bg-neutral-800 text-white"
: "border-border-default bg-white text-text-neutral-secondary hover:bg-neutral-50"
}`}
>
{label}
{ausgewaehlt.length ? (
<span className="rounded bg-white/20 px-1.5 text-[11px] font-semibold">
{ausgewaehlt.length}
</span>
) : null}
<FeatherChevronDown className="text-[14px]" />
</button>
{offen ? (
<div className="absolute left-0 top-9 z-50 flex w-64 flex-col rounded-lg border border-solid border-border-default bg-white shadow-lg">
{optionen.length >= suchbarAb ? (
<div className="flex items-center gap-2 border-b border-solid border-border-default px-3 py-2">
<FeatherSearch className="text-[14px] text-text-neutral-tertiary" />
<input
autoFocus
value={suche}
onChange={(event) => setSuche(event.target.value)}
placeholder="Suchen …"
className="w-full bg-transparent text-[13px] outline-none placeholder:text-text-neutral-subtle"
/>
</div>
) : null}
<div className="dv-scroll max-h-64 overflow-y-auto py-1">
{gefiltert.map((option) => {
const aktiv = ausgewaehlt.includes(option.wert);
return (
<button
key={option.wert}
onClick={() => onToggle(option.wert)}
className="flex w-full items-center gap-2.5 px-3 py-1.5 text-left text-[13px] text-text-neutral-primary hover:bg-neutral-50"
>
<span
className={`flex h-4 w-4 flex-none items-center justify-center rounded border border-solid ${
aktiv ? "border-neutral-800 bg-neutral-800 text-white" : "border-border-strong"
}`}
>
{aktiv ? <FeatherCheck className="text-[11px]" /> : null}
</span>
<span className="min-w-0 grow truncate">{option.label}</span>
{option.zusatz ? (
<span className="flex-none text-[12px] text-text-neutral-tertiary">
{option.zusatz}
</span>
) : null}
</button>
);
})}
{!gefiltert.length ? (
<div className="px-3 py-6 text-center text-[13px] text-text-neutral-tertiary">
Kein Treffer
</div>
) : null}
</div>
<div className="flex items-center justify-between border-t border-solid border-border-default px-3 py-2">
<button
onClick={onLeeren}
className="text-[12px] font-medium text-text-neutral-tertiary hover:text-text-neutral-primary"
>
Auswahl leeren
</button>
<button
onClick={() => setOffen(false)}
className="rounded-md bg-neutral-800 px-2.5 py-1 text-[12px] font-semibold text-white"
>
Fertig
</button>
</div>
</div>
) : null}
</div>
);
}
@@ -0,0 +1,159 @@
"use client";
import React from "react";
import Link from "next/link";
import { usePathname } from "next/navigation";
import {
FeatherBell,
FeatherHelpCircle,
FeatherPanelLeft,
FeatherSearch,
} from "@subframe/core";
import { ALLE_SEITEN, NAV_GRUPPEN } from "./navigation";
import { FeatherIcon } from "./FeatherIcon";
import { DATENSATZ_INFO } from "../../data/seed";
import { formatDatum, formatZahl } from "../../utils/formatters";
import { HEUTE } from "../../utils/dateUtils";
/**
* Rahmen der Anwendung: feste Seitenleiste links, Inhalt rechts.
*
* Warum Seitenleiste statt Tab-Leiste: Die echte HiveGrid-Oberfläche
* navigiert links; so passt der Prototyp beim Einbau ohne Umbau der
* Informationsarchitektur. Die Leiste lässt sich auf Icon-Breite einklappen,
* damit breite Tabellen und 12-Spalten-Raster Platz bekommen.
*/
export function AppShell({ children }: { children: React.ReactNode }) {
const pathname = usePathname();
const [eingeklappt, setEingeklappt] = React.useState(false);
const aktiveSeite =
ALLE_SEITEN.find((s) => s.href !== "/" && pathname.startsWith(s.href)) ??
ALLE_SEITEN.find((s) => s.href === "/");
return (
<div className="flex min-h-screen w-full bg-neutral-50">
<aside
className={`dv-no-print sticky top-0 flex h-screen flex-none flex-col border-r border-solid border-border-default bg-white transition-[width] duration-200 ${
eingeklappt ? "w-[68px]" : "w-[248px]"
}`}
>
<div className="flex h-14 flex-none items-center gap-2 border-b border-solid border-border-default px-4">
<span className="flex h-8 w-8 flex-none items-center justify-center rounded-lg bg-[#161616] text-[13px] font-bold text-white">
HG
</span>
{!eingeklappt ? (
<div className="flex min-w-0 flex-col">
<span className="truncate text-[13px] font-semibold leading-tight text-text-neutral-primary">
HiveGrid
</span>
<span className="truncate text-[11px] leading-tight text-text-neutral-tertiary">
Analytics
</span>
</div>
) : null}
</div>
<nav className="flex min-h-0 grow flex-col gap-5 overflow-y-auto px-3 py-4">
{NAV_GRUPPEN.map((gruppe) => (
<div key={gruppe.titel} className="flex flex-col gap-1">
{!eingeklappt ? (
<span className="px-2 pb-1 text-[11px] font-semibold uppercase tracking-[0.08em] text-text-neutral-tertiary">
{gruppe.titel}
</span>
) : (
<span className="mx-2 mb-1 h-px bg-border-default" />
)}
{gruppe.eintraege.map((eintrag) => {
const aktiv = eintrag.href === pathname;
return (
<Link
key={eintrag.href}
href={eintrag.href}
title={eingeklappt ? eintrag.label : eintrag.beschreibung}
aria-current={aktiv ? "page" : undefined}
className={`flex items-center gap-2.5 rounded-md px-2.5 py-2 text-[13px] font-medium transition-colors ${
aktiv
? "bg-neutral-100 text-text-neutral-primary"
: "text-text-neutral-secondary hover:bg-neutral-50 hover:text-text-neutral-primary"
}`}
>
<FeatherIcon
name={eintrag.icon}
className={`text-[17px] ${aktiv ? "text-text-neutral-primary" : "text-text-neutral-tertiary"}`}
/>
{!eingeklappt ? <span className="truncate">{eintrag.label}</span> : null}
</Link>
);
})}
</div>
))}
</nav>
<div className="flex-none border-t border-solid border-border-default px-3 py-3">
{!eingeklappt ? (
<div className="mb-3 rounded-md bg-neutral-50 px-3 py-2.5">
<div className="text-[11px] font-semibold uppercase tracking-wide text-text-neutral-tertiary">
Demo-Datenstand
</div>
<div className="mt-1 text-[12px] leading-relaxed text-text-neutral-secondary">
{formatZahl(DATENSATZ_INFO.auftraege)} Aufträge
<br />
{formatZahl(DATENSATZ_INFO.rechnungen)} Rechnungen
<br />
Stichtag {formatDatum(HEUTE.toISOString())}
</div>
</div>
) : null}
<button
onClick={() => setEingeklappt((wert) => !wert)}
className="flex w-full items-center gap-2.5 rounded-md px-2.5 py-2 text-[13px] font-medium text-text-neutral-tertiary hover:bg-neutral-50 hover:text-text-neutral-primary"
aria-label={eingeklappt ? "Seitenleiste ausklappen" : "Seitenleiste einklappen"}
>
<FeatherPanelLeft className="text-[17px]" />
{!eingeklappt ? <span>Einklappen</span> : null}
</button>
</div>
</aside>
<div className="flex min-w-0 grow flex-col">
<header className="dv-no-print sticky top-0 z-30 flex h-14 flex-none items-center gap-4 border-b border-solid border-border-default bg-white/95 px-6 backdrop-blur">
<div className="flex min-w-0 items-center gap-2 text-[13px]">
<span className="text-text-neutral-tertiary">Statistiken</span>
<span className="text-text-neutral-subtle">/</span>
<span className="truncate font-semibold text-text-neutral-primary">
{aktiveSeite?.label ?? "Übersicht"}
</span>
</div>
<div className="ml-auto flex items-center gap-2">
<div className="hidden h-9 items-center gap-2 rounded-md border border-solid border-border-default px-3 text-[13px] text-text-neutral-subtle lg:flex">
<FeatherSearch className="text-[15px]" />
<span>Suchen</span>
<kbd className="ml-4 rounded border border-solid border-border-default bg-neutral-50 px-1.5 py-0.5 text-[10px] font-medium text-text-neutral-tertiary">
⌘K
</kbd>
</div>
<button
className="flex h-9 w-9 items-center justify-center rounded-md text-text-neutral-tertiary hover:bg-neutral-100"
aria-label="Benachrichtigungen"
>
<FeatherBell className="text-[17px]" />
</button>
<button
className="flex h-9 w-9 items-center justify-center rounded-md text-text-neutral-tertiary hover:bg-neutral-100"
aria-label="Hilfe"
>
<FeatherHelpCircle className="text-[17px]" />
</button>
<span className="ml-1 flex h-8 w-8 items-center justify-center rounded-full bg-neutral-800 text-[12px] font-semibold text-white">
MK
</span>
</div>
</header>
<main className="min-w-0 grow">{children}</main>
</div>
</div>
);
}
@@ -0,0 +1,18 @@
"use client";
import React from "react";
import * as SubframeCore from "@subframe/core";
type IconKomponente = React.ComponentType<{ className?: string }>;
/**
* Löst einen Icon-Namen ("Euro") gegen das Feather-Set von @subframe/core auf.
* So können Konfigurationsdateien (navigation.ts) Icons als String führen,
* ohne React importieren zu müssen.
*/
export function FeatherIcon({ name, className }: { name: string; className?: string }) {
const registry = SubframeCore as unknown as Record<string, IconKomponente | undefined>;
const Komponente = registry[`Feather${name}`];
if (!Komponente) return null;
return <Komponente className={className} />;
}
@@ -0,0 +1,38 @@
import React from "react";
/**
* Inhaltsspalte einer Seite.
* 24 px Außenabstand, 16 px Rasterabstand — entspricht dem 8-px-System
* aus den UI-Guidelines (internal ≤ external).
*/
export function PageContainer({ children }: { children: React.ReactNode }) {
return <div className="flex flex-col gap-6 px-6 pb-10">{children}</div>;
}
/** Standard-Raster für eine Kartenreihe. */
export function Raster({
spalten,
/**
* Karten oben ausrichten statt auf gleiche Hoehe strecken.
* Gleiche Hoehe ist richtig, wenn alle Karten dieselbe Struktur haben
* (KPI-Reihe). Sobald ein Chart mit fester Hoehe neben einer Tabelle steht,
* erzeugt Strecken nur Weissraum.
*/
obenBuendig = false,
children,
}: {
/** Spaltenzahl auf großen Bildschirmen. */
spalten: 2 | 3 | 4 | 5;
obenBuendig?: boolean;
children: React.ReactNode;
}) {
const klassen: Record<number, string> = {
2: "grid grid-cols-1 gap-4 md:grid-cols-2",
3: "grid grid-cols-1 gap-4 md:grid-cols-2 xl:grid-cols-3",
4: "grid grid-cols-2 gap-4 lg:grid-cols-4",
5: "grid grid-cols-2 gap-4 lg:grid-cols-3 xl:grid-cols-5",
};
return (
<div className={`${klassen[spalten]} ${obenBuendig ? "items-start" : ""}`}>{children}</div>
);
}
@@ -0,0 +1,58 @@
"use client";
import React from "react";
import { FeatherDownload, FeatherRefreshCw, FeatherShare2 } from "@subframe/core";
import { useToast } from "../../context/ToastContext";
/**
* Kopf einer Analyse-Seite: Titel, Einordnung, Seitenaktionen.
* Die Aktionen sind im Prototyp bewusst folgenlos (Toast statt Export) —
* siehe HANDOVER.md, Abschnitt "Was noch Logik braucht".
*/
export function PageHeader({
titel,
beschreibung,
aktionen,
}: {
titel: string;
beschreibung: string;
aktionen?: React.ReactNode;
}) {
const { zeigeToast } = useToast();
return (
<div className="flex flex-wrap items-start justify-between gap-4 px-6 pb-6 pt-6">
<div className="flex min-w-0 flex-col gap-0">
<h1 className="text-[22px] font-semibold leading-tight tracking-[-0.02em] text-text-neutral-primary">
{titel}
</h1>
<p className="text-[13px] leading-relaxed text-text-neutral-tertiary">{beschreibung}</p>
</div>
<div className="dv-no-print flex flex-none items-center gap-2">
{aktionen}
<button
onClick={() => zeigeToast("Ansicht aktualisiert", "Demo-Daten, Stichtag 30.07.2026")}
className="flex h-9 items-center gap-2 rounded-md border border-solid border-border-default bg-white px-3 text-[13px] font-medium text-text-neutral-secondary hover:bg-neutral-50"
>
<FeatherRefreshCw className="text-[15px]" />
Aktualisieren
</button>
<button
onClick={() => zeigeToast("Export vorgemerkt", "PDF/CSV folgt in der Umsetzung")}
className="flex h-9 items-center gap-2 rounded-md border border-solid border-border-default bg-white px-3 text-[13px] font-medium text-text-neutral-secondary hover:bg-neutral-50"
>
<FeatherDownload className="text-[15px]" />
Export
</button>
<button
onClick={() => zeigeToast("Link kopiert", "Teilen wird serverseitig umgesetzt")}
className="flex h-9 w-9 items-center justify-center rounded-md border border-solid border-border-default bg-white text-text-neutral-tertiary hover:bg-neutral-50"
aria-label="Ansicht teilen"
>
<FeatherShare2 className="text-[15px]" />
</button>
</div>
</div>
);
}
@@ -0,0 +1,75 @@
import type { SeitenId } from "../../data/filtering";
export interface NavEintrag {
id: SeitenId | "komponenten";
href: string;
label: string;
/** Icon-Name aus @subframe/core (Feather-Set). */
icon: string;
beschreibung: string;
}
/**
* Navigationsstruktur.
*
* Vier Analyse-Seiten kommen direkt aus REQUIREMENTS-analytics.md
* (Übersicht, Finanzen, Aufträge, Kunden). "Team" war dort als v2 markiert,
* ist hier aber enthalten, weil Auslastung im Handwerk die Kennzahl ist,
* nach der Betriebe steuern. "Komponenten" ist reine Entwickler-Doku.
*/
export const NAV_GRUPPEN: { titel: string; eintraege: NavEintrag[] }[] = [
{
titel: "Analyse",
eintraege: [
{
id: "uebersicht",
href: "/",
label: "Übersicht",
icon: "LayoutDashboard",
beschreibung: "Alle Kernkennzahlen auf einen Blick",
},
{
id: "finanzen",
href: "/finanzen",
label: "Finanzen",
icon: "Euro",
beschreibung: "Umsatz, Rechnungen, Zahlungseingang",
},
{
id: "auftraege",
href: "/auftraege",
label: "Aufträge",
icon: "ClipboardList",
beschreibung: "Pipeline, Status, Termine",
},
{
id: "kunden",
href: "/kunden",
label: "Kunden",
icon: "Users",
beschreibung: "Akquise, Quellen, Bestand",
},
{
id: "team",
href: "/team",
label: "Team",
icon: "HardHat",
beschreibung: "Auslastung und Produktivität der Monteure",
},
],
},
{
titel: "Entwicklung",
eintraege: [
{
id: "komponenten",
href: "/komponenten",
label: "Komponenten",
icon: "Component",
beschreibung: "Bausteine, Regeln und Übergabehinweise",
},
],
},
];
export const ALLE_SEITEN = NAV_GRUPPEN.flatMap((g) => g.eintraege);
@@ -0,0 +1,215 @@
"use client";
import React from "react";
import {
FeatherArrowDown,
FeatherArrowUp,
FeatherChevronLeft,
FeatherChevronRight,
FeatherSearch,
} from "@subframe/core";
export interface Spalte<T> {
key: string;
titel: string;
/** Zellinhalt; darf beliebige Knoten liefern (Badges, Links). */
zelle: (zeile: T) => React.ReactNode;
/** Sortierwert — ohne diesen ist die Spalte nicht sortierbar. */
sortWert?: (zeile: T) => number | string;
/** Zahlen gehören rechtsbündig und in Tabellenziffern. */
numerisch?: boolean;
breite?: string;
}
/**
* Tabelle für Arbeitslisten (offene Rechnungen, Aufträge, Kunden).
*
* Enthält die Interaktionen, die man in einer Demo wirklich braucht:
* Sortieren per Klick auf den Spaltenkopf, Volltextsuche, Blättern.
* Alles clientseitig — bei echten Datenmengen gehört das auf den Server.
*/
export function DataTable<T extends { id: string }>({
zeilen,
spalten,
proSeite = 8,
suchbar = true,
suchFelder,
leerText = "Keine Einträge",
}: {
zeilen: T[];
spalten: Spalte<T>[];
proSeite?: number;
suchbar?: boolean;
/** Felder, die die Suche durchsucht. */
suchFelder?: (zeile: T) => string;
leerText?: string;
}) {
const [suche, setSuche] = React.useState("");
const [seite, setSeite] = React.useState(0);
const [sortierung, setSortierung] = React.useState<{ key: string; richtung: "asc" | "desc" } | null>(
null
);
const gefiltert = React.useMemo(() => {
if (!suche.trim() || !suchFelder) return zeilen;
const begriff = suche.toLowerCase();
return zeilen.filter((zeile) => suchFelder(zeile).toLowerCase().includes(begriff));
}, [zeilen, suche, suchFelder]);
const sortiert = React.useMemo(() => {
if (!sortierung) return gefiltert;
const spalte = spalten.find((s) => s.key === sortierung.key);
if (!spalte?.sortWert) return gefiltert;
return [...gefiltert].sort((a, b) => {
const wertA = spalte.sortWert!(a);
const wertB = spalte.sortWert!(b);
const vergleich =
typeof wertA === "number" && typeof wertB === "number"
? wertA - wertB
: String(wertA).localeCompare(String(wertB), "de");
return sortierung.richtung === "asc" ? vergleich : -vergleich;
});
}, [gefiltert, sortierung, spalten]);
const seiten = Math.max(1, Math.ceil(sortiert.length / proSeite));
const aktuelleSeite = Math.min(seite, seiten - 1);
const sichtbar = sortiert.slice(aktuelleSeite * proSeite, (aktuelleSeite + 1) * proSeite);
const sortiereNach = (key: string) => {
setSeite(0);
setSortierung((aktuell) =>
aktuell?.key === key
? { key, richtung: aktuell.richtung === "asc" ? "desc" : "asc" }
: { key, richtung: "desc" }
);
};
return (
<div className="flex flex-col gap-3">
{suchbar && suchFelder ? (
<div className="flex h-8 items-center gap-2 rounded-md border border-solid border-border-default px-2.5">
<FeatherSearch className="text-[14px] text-text-neutral-tertiary" />
<input
value={suche}
onChange={(event) => {
setSuche(event.target.value);
setSeite(0);
}}
placeholder="In Liste suchen …"
className="w-full bg-transparent text-[13px] outline-none placeholder:text-text-neutral-subtle"
/>
</div>
) : null}
<div className="dv-scroll -mx-1 overflow-x-auto px-1">
<table className="w-full border-collapse">
<thead>
<tr className="border-b border-solid border-border-default">
{spalten.map((spalte) => {
const aktiv = sortierung?.key === spalte.key;
return (
<th
key={spalte.key}
style={{ width: spalte.breite }}
aria-sort={
!spalte.sortWert
? undefined
: aktiv
? sortierung!.richtung === "asc"
? "ascending"
: "descending"
: "none"
}
className={`px-2 pb-2 text-[12px] font-medium text-text-neutral-tertiary ${
spalte.numerisch ? "text-right" : "text-left"
}`}
>
{spalte.sortWert ? (
<button
onClick={() => sortiereNach(spalte.key)}
className={`inline-flex items-center gap-1 hover:text-text-neutral-primary ${
spalte.numerisch ? "flex-row-reverse" : ""
} ${aktiv ? "text-text-neutral-primary" : ""}`}
>
{spalte.titel}
{aktiv ? (
sortierung!.richtung === "asc" ? (
<FeatherArrowUp className="text-[11px]" />
) : (
<FeatherArrowDown className="text-[11px]" />
)
) : null}
</button>
) : (
spalte.titel
)}
</th>
);
})}
</tr>
</thead>
<tbody>
{sichtbar.map((zeile) => (
<tr
key={zeile.id}
className="border-b border-solid border-border-default last:border-b-0"
>
{spalten.map((spalte) => (
<td
key={spalte.key}
className={`px-2 py-2.5 text-[13px] text-text-neutral-primary ${
spalte.numerisch ? "text-right tabular-nums" : "text-left"
}`}
>
{spalte.zelle(zeile)}
</td>
))}
</tr>
))}
{!sichtbar.length ? (
<tr>
<td
colSpan={spalten.length}
className="px-2 py-10 text-center text-[13px] text-text-neutral-tertiary"
>
{leerText}
</td>
</tr>
) : null}
</tbody>
</table>
</div>
{sortiert.length > proSeite ? (
<div className="dv-no-print flex items-center justify-between">
<span className="text-[12px] text-text-neutral-tertiary">
{aktuelleSeite * proSeite + 1}–{Math.min((aktuelleSeite + 1) * proSeite, sortiert.length)} von{" "}
{sortiert.length}
</span>
<div className="flex items-center gap-1">
<button
onClick={() => setSeite((s) => Math.max(0, s - 1))}
disabled={aktuelleSeite === 0}
aria-label="Vorherige Seite"
className="flex h-8 w-8 items-center justify-center rounded-md border border-solid border-border-default text-text-neutral-secondary disabled:opacity-40 enabled:hover:bg-neutral-50"
>
<FeatherChevronLeft className="text-[14px]" />
</button>
<span className="px-1 text-[12px] tabular-nums text-text-neutral-secondary">
{aktuelleSeite + 1} / {seiten}
</span>
<button
onClick={() => setSeite((s) => Math.min(seiten - 1, s + 1))}
disabled={aktuelleSeite >= seiten - 1}
aria-label="Nächste Seite"
className="flex h-8 w-8 items-center justify-center rounded-md border border-solid border-border-default text-text-neutral-secondary disabled:opacity-40 enabled:hover:bg-neutral-50"
>
<FeatherChevronRight className="text-[14px]" />
</button>
</div>
</div>
) : null}
</div>
);
}
@@ -0,0 +1,38 @@
import React from "react";
import type { AuftragStatus, RechnungStatus } from "../../data/types";
import { AUFTRAG_STATUS_LABEL, RECHNUNG_STATUS_LABEL } from "../../data/types";
import { BADGE_TON } from "../../utils/chartTheme";
/** Farbzuordnung: Endzustände neutral, Problemzustände rot, Laufendes blau. */
const AUFTRAG_TON: Record<AuftragStatus, string> = {
anfrage: BADGE_TON.neutral,
aufmass: BADGE_TON.information,
angebot: BADGE_TON.lila,
beauftragt: BADGE_TON.teal,
in_arbeit: BADGE_TON.positiv,
abgeschlossen: BADGE_TON.neutral,
verloren: BADGE_TON.negativ,
};
const RECHNUNG_TON: Record<RechnungStatus, string> = {
entwurf: BADGE_TON.neutral,
gestellt: BADGE_TON.information,
bezahlt: BADGE_TON.positiv,
ueberfaellig: BADGE_TON.negativ,
};
export function AuftragBadge({ status }: { status: AuftragStatus }) {
return (
<span className={`inline-block whitespace-nowrap rounded-full px-2 py-0.5 text-[11px] font-medium ${AUFTRAG_TON[status]}`}>
{AUFTRAG_STATUS_LABEL[status]}
</span>
);
}
export function RechnungBadge({ status }: { status: RechnungStatus }) {
return (
<span className={`inline-block whitespace-nowrap rounded-full px-2 py-0.5 text-[11px] font-medium ${RECHNUNG_TON[status]}`}>
{RECHNUNG_STATUS_LABEL[status]}
</span>
);
}