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,17 @@
"use client";
import React from "react";
import { FilterProvider } from "./FilterContext";
import { WidgetProvider } from "./WidgetContext";
import { ToastProvider } from "./ToastContext";
/** Sammelt alle Client-Provider, damit das Root-Layout schlank bleibt. */
export function DashboardProviders({ children }: { children: React.ReactNode }) {
return (
<FilterProvider>
<WidgetProvider>
<ToastProvider>{children}</ToastProvider>
</WidgetProvider>
</FilterProvider>
);
}
@@ -0,0 +1,70 @@
"use client";
import React from "react";
import { LEERER_FILTER, type FilterState } from "../data/types";
import { erstellePersistentenStore } from "./persistenterStore";
/**
* Globaler Filter-State über alle Analytics-Seiten hinweg (INFRA-01),
* persistiert in localStorage (INFRA-02) — ein Reload verwirft die Auswahl
* nicht, im Kundentermin ein spürbarer Unterschied.
*/
export type MehrfachFeld =
| "gewerke"
| "auftragStatus"
| "kundenQuellen"
| "regionen"
| "mitarbeiterIds";
const store = erstellePersistentenStore<FilterState>(
"hivegrid.analytics.filter.v1",
LEERER_FILTER
);
interface FilterContextValue {
filter: FilterState;
setFilter: (naechster: FilterState | ((vorher: FilterState) => FilterState)) => void;
/** Einzelnen Mehrfachwert an- oder abwählen. */
toggleWert: (feld: MehrfachFeld, wert: string) => void;
/** Ein Feld komplett leeren. */
leereFeld: (feld: MehrfachFeld) => void;
zuruecksetzen: () => void;
}
const FilterContext = React.createContext<FilterContextValue | null>(null);
export function FilterProvider({ children }: { children: React.ReactNode }) {
const filter = React.useSyncExternalStore(
store.subscribe,
store.getSnapshot,
store.getServerSnapshot
);
const wert = React.useMemo<FilterContextValue>(
() => ({
filter,
setFilter: store.setzen,
toggleWert: (feld, eintrag) =>
store.setzen((aktuell) => {
const liste = aktuell[feld] as string[];
const neu = liste.includes(eintrag)
? liste.filter((w) => w !== eintrag)
: [...liste, eintrag];
return { ...aktuell, [feld]: neu } as FilterState;
}),
leereFeld: (feld) =>
store.setzen((aktuell) => ({ ...aktuell, [feld]: [] }) as FilterState),
zuruecksetzen: () => store.setzen(LEERER_FILTER),
}),
[filter]
);
return <FilterContext.Provider value={wert}>{children}</FilterContext.Provider>;
}
export function useFilter(): FilterContextValue {
const ctx = React.useContext(FilterContext);
if (!ctx) throw new Error("useFilter muss innerhalb von <FilterProvider> verwendet werden");
return ctx;
}
@@ -0,0 +1,65 @@
"use client";
import React from "react";
import { FeatherCheck, FeatherInfo } from "@subframe/core";
/**
* Minimale Rückmeldung für Demo-Aktionen (Export, Speichern, Teilen).
*
* Im Prototyp passiert dahinter nichts — der Toast macht aber sichtbar,
* dass der Klick registriert wurde, statt dass der Button "tot" wirkt.
* In der echten Software durch die vorhandene Toast-Komponente ersetzen.
*/
interface ToastContextValue {
zeigeToast: (text: string, detail?: string) => void;
}
const ToastContext = React.createContext<ToastContextValue | null>(null);
export function ToastProvider({ children }: { children: React.ReactNode }) {
const [toast, setToast] = React.useState<{ text: string; detail?: string } | null>(null);
const timer = React.useRef<ReturnType<typeof setTimeout> | null>(null);
const zeigeToast = React.useCallback((text: string, detail?: string) => {
setToast({ text, detail });
if (timer.current) clearTimeout(timer.current);
timer.current = setTimeout(() => setToast(null), 2600);
}, []);
React.useEffect(() => () => {
if (timer.current) clearTimeout(timer.current);
}, []);
return (
<ToastContext.Provider value={{ zeigeToast }}>
{children}
{toast ? (
<div
role="status"
aria-live="polite"
className="dv-no-print fixed bottom-6 right-6 z-[200] flex max-w-sm items-start gap-3 rounded-lg border border-solid border-border-default bg-white px-4 py-3 shadow-lg"
>
<span className="mt-0.5 flex h-7 w-7 flex-none items-center justify-center rounded-full bg-[#defbe6] text-[#198038]">
<FeatherCheck className="text-[15px]" />
</span>
<div className="flex flex-col gap-0.5">
<span className="text-[13px] font-semibold text-text-neutral-primary">{toast.text}</span>
{toast.detail ? (
<span className="flex items-center gap-1.5 text-[12px] text-text-neutral-tertiary">
<FeatherInfo className="text-[12px]" />
{toast.detail}
</span>
) : null}
</div>
</div>
) : null}
</ToastContext.Provider>
);
}
export function useToast(): ToastContextValue {
const ctx = React.useContext(ToastContext);
if (!ctx) throw new Error("useToast muss innerhalb von <ToastProvider> verwendet werden");
return ctx;
}
@@ -0,0 +1,69 @@
"use client";
import React from "react";
import { erstellePersistentenStore } from "./persistenterStore";
/**
* Sichtbarkeit einzelner Widgets.
*
* Jede Karte hat eine stabile ID; über das ⋯-Menü lässt sie sich ausblenden.
* Ausgeblendete Karten sammelt die Filterleiste und macht sie einzeln oder
* gesammelt wieder sichtbar. Der Zustand überlebt einen Reload.
*/
interface WidgetState {
versteckt: string[];
/** Titel für die "wieder einblenden"-Liste. */
titel: Record<string, string>;
}
const STANDARD: WidgetState = { versteckt: [], titel: {} };
const store = erstellePersistentenStore<WidgetState>("hivegrid.analytics.widgets.v1", STANDARD);
interface WidgetContextValue extends WidgetState {
istSichtbar: (id: string) => boolean;
verstecke: (id: string, titel: string) => void;
zeige: (id: string) => void;
zeigeAlle: () => void;
}
const WidgetContext = React.createContext<WidgetContextValue | null>(null);
export function WidgetProvider({ children }: { children: React.ReactNode }) {
const zustand = React.useSyncExternalStore(
store.subscribe,
store.getSnapshot,
store.getServerSnapshot
);
const wert = React.useMemo<WidgetContextValue>(
() => ({
versteckt: zustand.versteckt,
titel: zustand.titel,
istSichtbar: (id) => !zustand.versteckt.includes(id),
verstecke: (id, kartenTitel) =>
store.setzen((aktuell) => ({
versteckt: aktuell.versteckt.includes(id)
? aktuell.versteckt
: [...aktuell.versteckt, id],
titel: { ...aktuell.titel, [id]: kartenTitel },
})),
zeige: (id) =>
store.setzen((aktuell) => ({
...aktuell,
versteckt: aktuell.versteckt.filter((eintrag) => eintrag !== id),
})),
zeigeAlle: () => store.setzen((aktuell) => ({ ...aktuell, versteckt: [] })),
}),
[zustand]
);
return <WidgetContext.Provider value={wert}>{children}</WidgetContext.Provider>;
}
export function useWidgets(): WidgetContextValue {
const ctx = React.useContext(WidgetContext);
if (!ctx) throw new Error("useWidgets muss innerhalb von <WidgetProvider> verwendet werden");
return ctx;
}
@@ -0,0 +1,60 @@
/**
* Kleiner Store für Werte, die einen Reload überleben sollen.
*
* Warum kein `useState` + `useEffect`: Beim Serverrendering gibt es keinen
* localStorage. Lädt man den gespeicherten Wert nachträglich im Effekt, löst
* das eine zweite Renderrunde aus (und React beanstandet das zu Recht).
* `useSyncExternalStore` ist genau für diesen Fall gebaut: Es rendert
* serverseitig den Standardwert und wechselt nach der Hydration auf den
* gespeicherten — ohne Mismatch und ohne Zusatzrender.
*/
export interface PersistenterStore<T> {
subscribe: (hoerer: () => void) => () => void;
getSnapshot: () => T;
getServerSnapshot: () => T;
setzen: (naechster: T | ((vorher: T) => T)) => void;
}
export function erstellePersistentenStore<T>(
schluessel: string,
standard: T,
/** Gelesene Daten mit dem Standard verschmelzen — fängt alte Formate ab. */
zusammenfuehren: (gespeichert: unknown, standard: T) => T = (g, s) =>
({ ...s, ...(g as object) }) as T
): PersistenterStore<T> {
let wert = standard;
let gelesen = false;
const hoerer = new Set<() => void>();
function lade(): T {
if (gelesen || typeof window === "undefined") return wert;
gelesen = true;
try {
const roh = window.localStorage.getItem(schluessel);
if (roh) wert = zusammenfuehren(JSON.parse(roh), standard);
} catch {
// Defektes JSON oder gesperrter Storage: beim Standard bleiben.
}
return wert;
}
return {
subscribe(neuerHoerer) {
hoerer.add(neuerHoerer);
return () => hoerer.delete(neuerHoerer);
},
getSnapshot: () => lade(),
getServerSnapshot: () => standard,
setzen(naechster) {
lade();
wert = typeof naechster === "function" ? (naechster as (v: T) => T)(wert) : naechster;
try {
window.localStorage.setItem(schluessel, JSON.stringify(wert));
} catch {
// Privater Modus o. Ä. — Persistenz ist optional.
}
hoerer.forEach((h) => h());
},
};
}