Datenvisualisierung mit Recharts: Dashboard-Muster

Ein gutes Dashboard besteht nicht nur aus Zahlen in einer Tabelle – es sind visuelle Muster, die Trends, Anomalien und Chancen auf einen Blick erkennen lassen. Recharts ist die am weitesten verbreitete Diagrammbibliothek im React-Ökosystem: basiert auf den Grundlagen von D3.j, ist vollständig TypeScript-typisiert, zusammensetzbar und sofort reaktionsfähig. Es bewältigt die SVG-Komplexität, sodass Sie sich auf die Datengeschichte konzentrieren können.

Dieser Leitfaden behandelt Recharts-Muster für Produktions-Dashboards – Umsatztrends, Conversion-Trichter, Zeitreihenmetriken, geografische Verteilung und Echtzeit-Streaming-Daten – mit Unterstützung für den Dunkelmodus, zugänglichen Farbpaletten und reaktionsfähigen Layouts.

Wichtige Erkenntnisse

– Wickeln Sie Diagramme immer in ResponsiveContainer mit width="100%" und einem festen height ein – codieren Sie niemals Pixelbreiten fest – Verwenden Sie CustomTooltip-Komponenten anstelle der Standardkomponenten – vollständige Kontrolle über Formatierung und Stil

• Rückrufparameter von Recharts formatter sollten NIEMALS explizit eingegeben werden – verwenden Sie Number(value) zum Konvertieren – Der Dunkelmodus erfordert dynamische Farbwerte – gelesen aus CSS-Variablen, nicht fest codierte Hex-Farben – Verwenden Sie für Zeitreihendaten einen tickFormatter auf der XAchse, um Zeitstempel konsistent zu formatieren
• Barrierefreiheit: Fügen Sie aria-label zum Diagrammcontainer hinzu und verwenden Sie tabIndex für Legendenelemente – Leistung: Diagrammdaten mit useMemo speichern – Recharts werden bei jedem übergeordneten Rendering erneut gerendert – Aktualisieren Sie für Echtzeitdaten die Datenarray-Referenz – Recharts erkennt Änderungen anhand der Referenz

---

Einrichtung

pnpm add recharts
pnpm add -D @types/recharts  # Usually not needed — recharts ships its own types

Recharts 2.x liefert TypeScript-Typen. Kein separates @types-Paket erforderlich.

---

Umsatzbereichsdiagramm

// src/components/charts/revenue-area-chart.tsx
'use client';

import { useMemo } from 'react';
import {
  AreaChart, Area, XAxis, YAxis, CartesianGrid,
  Tooltip, Legend, ResponsiveContainer,
} from 'recharts';
import { format, parseISO } from 'date-fns';

interface RevenueDataPoint {
  date: string;       // ISO date string
  revenue: number;
  refunds: number;
  net: number;
}

interface CustomTooltipProps {
  active?: boolean;
  payload?: Array<{ name: string; value: number; color: string }>;
  label?: string;
}

function CustomTooltip({ active, payload, label }: CustomTooltipProps) {
  if (!active || !payload || !label) return null;

  return (
    <div className="rounded-lg border bg-background p-3 shadow-md">
      <p className="mb-2 text-sm font-medium text-muted-foreground">
        {format(parseISO(label), 'MMM d, yyyy')}
      </p>
      {payload.map((entry) => (
        <div key={entry.name} className="flex items-center gap-2 text-sm">
          <span
            className="inline-block h-2 w-2 rounded-full"
            style={{ backgroundColor: entry.color }}
          />
          <span className="text-muted-foreground">{entry.name}:</span>
          <span className="font-medium">
            {new Intl.NumberFormat('en-US', {
              style: 'currency',
              currency: 'USD',
              maximumFractionDigits: 0,
            }).format(entry.value)}
          </span>
        </div>
      ))}
    </div>
  );
}

interface RevenueAreaChartProps {
  data: RevenueDataPoint[];
  loading?: boolean;
}

export function RevenueAreaChart({ data, loading }: RevenueAreaChartProps) {
  // CRITICAL: memoize chart data — Recharts re-renders on every reference change
  const chartData = useMemo(() => data, [data]);

  if (loading) {
    return <div className="h-80 animate-pulse rounded-lg bg-muted" />;
  }

  return (
    <div role="img" aria-label="Monthly revenue area chart">
      <ResponsiveContainer width="100%" height={320}>
        <AreaChart data={chartData} margin={{ top: 10, right: 30, left: 0, bottom: 0 }}>
          <defs>
            <linearGradient id="colorRevenue" x1="0" y1="0" x2="0" y2="1">
              <stop offset="5%"  stopColor="#f59e0b" stopOpacity={0.3} />
              <stop offset="95%" stopColor="#f59e0b" stopOpacity={0} />
            </linearGradient>
            <linearGradient id="colorNet" x1="0" y1="0" x2="0" y2="1">
              <stop offset="5%"  stopColor="#22c55e" stopOpacity={0.3} />
              <stop offset="95%" stopColor="#22c55e" stopOpacity={0} />
            </linearGradient>
          </defs>

          <CartesianGrid
            strokeDasharray="3 3"
            stroke="hsl(var(--border))"
            vertical={false}
          />

          <XAxis
            dataKey="date"
            tickFormatter={(value: string) => format(parseISO(value), 'MMM d')}
            tick={{ fontSize: 12, fill: 'hsl(var(--muted-foreground))' }}
            axisLine={false}
            tickLine={false}
          />

          <YAxis
            tickFormatter={(value) => `$${(Number(value) / 1000).toFixed(0)}k`}
            tick={{ fontSize: 12, fill: 'hsl(var(--muted-foreground))' }}
            axisLine={false}
            tickLine={false}
            width={60}
          />

          <Tooltip content={<CustomTooltip />} />

          <Legend
            wrapperStyle={{ fontSize: '14px', paddingTop: '16px' }}
            formatter={(value: string) =>
              <span className="text-foreground">{value}</span>
            }
          />

          <Area
            type="monotone"
            dataKey="revenue"
            name="Gross Revenue"
            stroke="#f59e0b"
            strokeWidth={2}
            fill="url(#colorRevenue)"
          />
          <Area
            type="monotone"
            dataKey="net"
            name="Net Revenue"
            stroke="#22c55e"
            strokeWidth={2}
            fill="url(#colorNet)"
          />
        </AreaChart>
      </ResponsiveContainer>
    </div>
  );
}

---

Balkendiagramm: Monatsvergleich

// src/components/charts/monthly-bar-chart.tsx
'use client';

import {
  BarChart, Bar, XAxis, YAxis, CartesianGrid,
  Tooltip, Legend, ResponsiveContainer, Cell,
} from 'recharts';

interface MonthlyData {
  month: string;
  current: number;
  previous: number;
  target: number;
}

function CustomBarTooltip({ active, payload, label }: any) {
  if (!active || !payload) return null;

  return (
    <div className="rounded-lg border bg-background p-3 shadow-md">
      <p className="mb-2 font-medium">{label}</p>
      {payload.map((entry: { name: string; value: number; fill: string }) => (
        <div key={entry.name} className="flex items-center gap-2 text-sm">
          <span
            className="inline-block h-2 w-2 rounded-full"
            style={{ backgroundColor: entry.fill }}
          />
          <span className="text-muted-foreground">{entry.name}:</span>
          <span className="font-medium">
            {new Intl.NumberFormat('en-US', {
              style: 'currency',
              currency: 'USD',
              maximumFractionDigits: 0,
            }).format(entry.value)}
          </span>
        </div>
      ))}
    </div>
  );
}

export function MonthlyBarChart({ data }: { data: MonthlyData[] }) {
  return (
    <ResponsiveContainer width="100%" height={300}>
      <BarChart data={data} margin={{ top: 5, right: 30, left: 20, bottom: 5 }}>
        <CartesianGrid strokeDasharray="3 3" stroke="hsl(var(--border))" vertical={false} />
        <XAxis
          dataKey="month"
          tick={{ fontSize: 12, fill: 'hsl(var(--muted-foreground))' }}
          axisLine={false}
          tickLine={false}
        />
        <YAxis
          tickFormatter={(value) => `$${(Number(value) / 1000).toFixed(0)}k`}
          tick={{ fontSize: 12, fill: 'hsl(var(--muted-foreground))' }}
          axisLine={false}
          tickLine={false}
        />
        <Tooltip content={<CustomBarTooltip />} />
        <Legend />
        <Bar dataKey="previous" name="Previous Year" fill="hsl(var(--muted))" radius={[4, 4, 0, 0]} />
        <Bar dataKey="current"  name="Current Year"  fill="#f59e0b"            radius={[4, 4, 0, 0]} />
        <Bar dataKey="target"   name="Target"        fill="#22c55e" opacity={0.4} radius={[4, 4, 0, 0]} />
      </BarChart>
    </ResponsiveContainer>
  );
}

---

Donut-/Kreisdiagramm

// src/components/charts/platform-pie-chart.tsx
'use client';

import { useState } from 'react';
import {
  PieChart, Pie, Cell, Sector,
  ResponsiveContainer, Legend, Tooltip,
} from 'recharts';

interface PieDataPoint {
  name: string;
  value: number;
  color: string;
}

const PLATFORM_COLORS: Record<string, string> = {
  'Odoo':         '#714b67',
  'Shopify':      '#96bf48',
  'GoHighLevel':  '#f59e0b',
  'Power BI':     '#f2c811',
  'OpenClaw':     '#0ea5e9',
  'Other':        '#94a3b8',
};

function renderActiveShape(props: any) {
  const {
    cx, cy, innerRadius, outerRadius, startAngle, endAngle,
    fill, payload, percent, value,
  } = props;

  return (
    <g>
      <text x={cx} y={cy - 12} textAnchor="middle" className="text-base font-bold fill-foreground">
        {payload.name}
      </text>
      <text x={cx} y={cy + 12} textAnchor="middle" className="text-sm fill-muted-foreground">
        {`${(percent * 100).toFixed(1)}%`}
      </text>
      <text x={cx} y={cy + 32} textAnchor="middle" className="text-sm fill-muted-foreground">
        {`$${(Number(value) / 1000).toFixed(0)}k`}
      </text>
      <Sector
        cx={cx} cy={cy}
        innerRadius={innerRadius}
        outerRadius={outerRadius + 8}
        startAngle={startAngle}
        endAngle={endAngle}
        fill={fill}
      />
      <Sector
        cx={cx} cy={cy}
        innerRadius={outerRadius + 10}
        outerRadius={outerRadius + 12}
        startAngle={startAngle}
        endAngle={endAngle}
        fill={fill}
      />
    </g>
  );
}

export function PlatformPieChart({ data }: { data: PieDataPoint[] }) {
  const [activeIndex, setActiveIndex] = useState(0);

  const chartData = data.map((item) => ({
    ...item,
    color: PLATFORM_COLORS[item.name] ?? '#94a3b8',
  }));

  return (
    <ResponsiveContainer width="100%" height={300}>
      <PieChart>
        <Pie
          activeIndex={activeIndex}
          activeShape={renderActiveShape}
          data={chartData}
          cx="50%"
          cy="50%"
          innerRadius={70}
          outerRadius={100}
          dataKey="value"
          onMouseEnter={(_, index) => setActiveIndex(index)}
        >
          {chartData.map((entry, index) => (
            <Cell key={`cell-${index}`} fill={entry.color} />
          ))}
        </Pie>
        <Legend
          formatter={(value: string) =>
            <span className="text-sm text-foreground">{value}</span>
          }
        />
      </PieChart>
    </ResponsiveContainer>
  );
}

---

Echtzeit-Liniendiagramm

// src/components/charts/realtime-chart.tsx
'use client';

import { useState, useEffect, useRef } from 'react';
import {
  LineChart, Line, XAxis, YAxis, CartesianGrid,
  Tooltip, ResponsiveContainer, ReferenceLine,
} from 'recharts';

interface MetricPoint {
  time: string;
  requests: number;
  errors: number;
  p95: number;
}

const MAX_DATA_POINTS = 60; // 60 seconds of data

export function RealtimeChart({ endpoint }: { endpoint: string }) {
  const [data, setData] = useState<MetricPoint[]>([]);
  const intervalRef = useRef<ReturnType<typeof setInterval>>();

  useEffect(() => {
    const fetchMetrics = async () => {
      try {
        const response = await fetch(endpoint);
        const point: MetricPoint = await response.json();

        setData((prev) => {
          const updated = [
            ...prev,
            { ...point, time: new Date().toLocaleTimeString() },
          ];
          // Keep only the last MAX_DATA_POINTS — sliding window
          return updated.slice(-MAX_DATA_POINTS);
        });
      } catch {
        // Metrics fetch failure is non-critical — log but do not crash
      }
    };

    fetchMetrics();
    intervalRef.current = setInterval(fetchMetrics, 1000);

    return () => {
      if (intervalRef.current) {
        clearInterval(intervalRef.current);
      }
    };
  }, [endpoint]);

  return (
    <ResponsiveContainer width="100%" height={200}>
      <LineChart data={data}>
        <CartesianGrid strokeDasharray="3 3" stroke="hsl(var(--border))" />
        <XAxis
          dataKey="time"
          tick={{ fontSize: 10, fill: 'hsl(var(--muted-foreground))' }}
          interval="preserveStartEnd"
        />
        <YAxis
          tick={{ fontSize: 10, fill: 'hsl(var(--muted-foreground))' }}
          axisLine={false}
        />
        <Tooltip />
        {/* Reference line for SLO threshold */}
        <ReferenceLine
          y={200}
          label={{ value: 'SLO 200ms', position: 'right', fontSize: 10 }}
          stroke="#ef4444"
          strokeDasharray="4 4"
        />
        <Line
          type="monotone"
          dataKey="p95"
          name="P95 Latency (ms)"
          stroke="#f59e0b"
          strokeWidth={2}
          dot={false}
          isAnimationActive={false} // Disable animation for real-time data
        />
        <Line
          type="monotone"
          dataKey="errors"
          name="Errors/s"
          stroke="#ef4444"
          strokeWidth={2}
          dot={false}
          isAnimationActive={false}
        />
      </LineChart>
    </ResponsiveContainer>
  );
}

---

Dashboard-Layout mit Statistikkarten

// src/components/dashboard/metrics-dashboard.tsx
'use client';

import { useQuery } from '@tanstack/react-query';
import { apiFetch } from '@/lib/api';
import { RevenueAreaChart } from './revenue-area-chart';
import { MonthlyBarChart } from './monthly-bar-chart';
import { PlatformPieChart } from './platform-pie-chart';

export function MetricsDashboard() {
  const { data: metrics, isLoading } = useQuery({
    queryKey: ['dashboard-metrics'],
    queryFn: () => apiFetch<DashboardMetrics>('/analytics/dashboard'),
    refetchInterval: 5 * 60 * 1000, // Refetch every 5 minutes
  });

  return (
    <div className="space-y-6">
      {/* KPI Cards */}
      <div className="grid grid-cols-2 gap-4 lg:grid-cols-4">
        {[
          { label: 'MRR', value: metrics?.mrr, format: 'currency', trend: '+12%' },
          { label: 'ARR',  value: metrics?.arr,  format: 'currency', trend: '+8%'  },
          { label: 'Customers', value: metrics?.customers, format: 'number', trend: '+23' },
          { label: 'Churn', value: metrics?.churnRate, format: 'percent', trend: '-0.3%' },
        ].map(({ label, value, format, trend }) => (
          <div key={label} className="rounded-lg border bg-card p-4">
            <p className="text-sm text-muted-foreground">{label}</p>
            <p className="mt-1 text-2xl font-bold">
              {isLoading ? (
                <span className="inline-block h-8 w-24 animate-pulse rounded bg-muted" />
              ) : (
                formatMetric(value, format)
              )}
            </p>
            <p className="mt-1 text-sm text-green-500">{trend} this month</p>
          </div>
        ))}
      </div>

      {/* Charts */}
      <div className="grid gap-6 lg:grid-cols-3">
        <div className="lg:col-span-2 rounded-lg border bg-card p-6">
          <h3 className="mb-4 text-lg font-semibold">Revenue Trend</h3>
          <RevenueAreaChart data={metrics?.revenueByDay ?? []} loading={isLoading} />
        </div>
        <div className="rounded-lg border bg-card p-6">
          <h3 className="mb-4 text-lg font-semibold">Revenue by Platform</h3>
          <PlatformPieChart data={metrics?.revenueByPlatform ?? []} />
        </div>
      </div>

      <div className="rounded-lg border bg-card p-6">
        <h3 className="mb-4 text-lg font-semibold">Monthly Comparison</h3>
        <MonthlyBarChart data={metrics?.monthlyComparison ?? []} />
      </div>
    </div>
  );
}

function formatMetric(value: number | undefined, format: string): string {
  if (value === undefined) return '—';
  const fmt = new Intl.NumberFormat('en-US');
  if (format === 'currency') return `$${fmt.format(value)}`;
  if (format === 'percent') return `${value.toFixed(1)}%`;
  return fmt.format(value);
}

---

Häufig gestellte Fragen

Warum müssen Recharts Tooltip-Formatierungsrückrufe ihre Parameter niemals explizit eingeben?

Die TypeScript-Typen von Recharts für die Requisite formatter sind auf eine Weise überladen, die zu Typkonflikten führt, wenn Sie die Parameter mit Anmerkungen versehen. Das richtige Muster besteht darin, Number(value) zu verwenden, um den Wert sicher zu konvertieren, ohne den Typ von value zu kommentieren. Wenn Sie es als (value: number) annotieren, kann TypeScript aufgrund des Union-Typs in der internen Signatur von Recharts einen Fehler verursachen. Lassen Sie TypeScript den Typ ableiten und mit Number(value) konvertieren.

Wie sorge ich dafür, dass Recharts-Diagramme im dunklen Modus funktionieren?

Verwenden Sie benutzerdefinierte CSS-Eigenschaften (Variablen) für alle Farben anstelle von fest codierten Hexadezimalwerten. Referenzieren Sie sie mit hsl(var(--border)) für Rasterlinien, hsl(var(--muted-foreground)) für Achsentext und hsl(var(--background)) für Tooltip-Hintergründe. Diese Variablen werden in Ihrem Tailwind-Design definiert und schalten die Werte über die Klasse dark auf <html> automatisch zwischen Hell- und Dunkelmodus um. Kodieren Sie #374151 niemals fest – es wird nicht mit dem Thema aktualisiert.

Wie gehe ich mit Leer- oder Ladezuständen für Diagramme um?

Zum Laden: Ersetzen Sie das Diagramm durch ein Skelett (animate-pulse bg-muted rounded-lg h-80). Für leere Daten: Rendern Sie eine zentrierte leere Statusmeldung innerhalb eines ResponsiveContainer. Für Teildaten: Recharts verarbeitet spärliche Daten elegant – übergeben Sie einfach, was Sie haben, und es verbindet die Punkte (oder zeigt Lücken für Nullwerte mit connectNulls={false} an).

Soll ich Recharts oder Chart.js oder D3 verwenden?

Recharts für React-native Dashboards – es ist deklarativ, zusammensetzbar und lässt sich auf natürliche Weise in das Rendering-Modell von React integrieren. Chart.js für einfachere Anwendungsfälle, bei denen Sie einen Canvas-basierten Renderer wünschen (bessere Leistung für mehr als 10.000 Datenpunkte). D3, wenn Sie benutzerdefinierte, nicht standardmäßige Diagrammtypen benötigen, die keine Bibliothek abdeckt – erwarten Sie deutlich mehr Code. Vermeiden Sie die Kombination mehrerer Diagrammbibliotheken in einer Anwendung.

Wie exportiere ich Diagramme als Bilder für Berichte?

Verwenden Sie die Bibliothek html2canvas, um den Diagrammcontainer als Bild zu erfassen: const canvas = await html2canvas(chartRef.current); const url = canvas.toDataURL('image/png');. Alternativ können Sie die integrierte SVG-Ausgabe von Recharts verwenden. Da Recharts SVG rendert, können Sie das SVG-Element direkt für den Vektorexport serialisieren. Für PDF-Berichte rendern Sie Diagramme serverseitig mit Puppeteer oder einem Headless-Browser.

---

Nächste Schritte

Datenvisualisierung wandelt Rohmetriken in Business Intelligence um. Die Muster in diesem Leitfaden – reaktionsfähige Container, benutzerdefinierte Tooltips, Echtzeit-Streaming und themenbezogene Farben – bilden die Grundlage für Dashboard-Benutzeroberflächen, die auf jedem Gerät und in jedem Farbschema klar kommunizieren.

ECOSIRE erstellt Analyse-Dashboards mit Recharts in 8 Dashboard-Modulen für Finanz-, Betriebs- und Leistungsmetriken – mit Live-Daten von NestJS-APIs und Drizzle-basiertem PostgreSQL. Für Business Intelligence- und Power BI-Implementierungen [entdecken Sie unsere Power BI-Dienste] (/services/powerbi) oder [sehen Sie sich alle unsere Dienste an] (/services).