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:
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());
|
||||
},
|
||||
};
|
||||
}
|
||||
Reference in new issue
Block a user