# KERN React Kit - Komponenten-Dokumentation

[![Version](https://img.shields.io/npm/v/@kern-ux-annex/kern-react-kit)](https://www.npmjs.com/package/@kern-ux-annex/kern-react-kit)
[![Storybook](https://img.shields.io/badge/Storybook-Live-blue)](https://kern-react-kit-75d4e7.usercontent.opencode.de/)

## Components (v2.37.0)

This document provides a comprehensive overview of all components available in the KERN React Kit package.

**📖 Interaktive Dokumentation:** Alle Komponenten sind im [**Storybook**](https://kern-react-kit-75d4e7.usercontent.opencode.de/) verfügbar mit Live-Beispielen und konfigurierbaren Properties.

## 📋 Komponenten-Übersicht

**Insgesamt 46 Komponenten:** 33 Kern-Komponenten + 13 Addon-Komponenten

### Core Components (33)

- **Basis:** KernAlert, KernBadge, KernButton, KernCard, KernDialog, KernDivider, KernHeading, KernIcon, KernKopfzeile, KernLink, KernList, KernLoader, KernProgress, KernSpace, KernText (15)
- **Formulare:** KernCheckbox, KernFieldset, KernForm, KernInput, KernInputDate, KernRadio, KernRadioGroup, KernSelect, KernTextarea (9)
- **Layout:** KernAccordion, KernColumn, KernContainer, KernRow (4)
- **Daten:** KernDescriptionList, KernSummary, KernSummaryGroup, KernTable, KernTaskList, KernTaskListGroup (6)

### Addon-Komponenten (13)

- **Allgemein:** KernSidebar, KernSidebarItem, KernToggleDarkMode, KernDialogProvider, useDialog, useDialogSafe
- **Menu/Menubar:** KernMenubar, KernSubMenu, KernMenu, KernMenuitem
- **Tabs:** KernTabs, KernTabList, KernTab, KernTabPanels, KernTabPanel, useTabs

## Inhaltsverzeichnis

- [Größen und Level System](#größen-und-level-system)
- [Basis-Komponenten](#basis-komponenten)
- [Formular-Komponenten](#formular-komponenten)
- [Layout-Komponenten](#layout-komponenten)
- [Daten-Komponenten](#daten-komponenten)
- [Zusätzliche Komponenten](#zusätzliche-komponenten)
- [Best Practices](#best-practices)
- [Troubleshooting](#troubleshooting)
- [Weitere Ressourcen](#weitere-ressourcen)

## Größen und Level System

KERN React Kit verwendet ein konsistentes System für Größen und semantische Level:

### Level-System (KernHeading)

Überschriften verwenden semantische HTML-Level (h1-h6) mit entsprechenden Standard-Größen:

- **Level 1**: `display` (größte Überschrift)
- **Level 2**: `x-large`
- **Level 3**: `large`
- **Level 4**: `medium`
- **Level 5**: `small`
- **Level 6**: `small`

### Größen-System

Verfügbare Größen variieren je nach Komponente:

**KernHeading**: `display`, `x-large`, `large`, `medium`, `small`
**KernText**: `large`, `small` (oder leer für Standard)
**KernIcon**: `small`, `medium`, `large`

### Text-Typen (KernText)

KernText unterstützt verschiedene semantische Text-Typen:

- **`title`**: Haupttitel und wichtige Überschriften
- **`preline`**: Vorspann-Text oberhalb des Titels
- **`subline`**: Untertitel unterhalb des Titels
- **`label`**: Beschriftungen und Labels
- **`body`**: Standard-Fließtext (Default)

## Basis-Komponenten

### KernButton

Ein vielseitiger Button mit verschiedenen Varianten, Icon-Unterstützung und Link-Funktionalität.

**Props:**

```typescript
interface KernButtonProps {
  label?: string;           // Button text (alternative to children)
  children?: ReactNode;     // Button content
  variant?: 'primary' | 'secondary' | 'tertiary' | 'success' | 'warning' | 'danger';
  type?: 'button' | 'submit' | 'reset';
  disabled?: boolean;
  onClick?: () => void;
  icon?: KernIconType;      // Icon name (e.g., 'arrow-forward', 'check', 'add')
  iconPosition?: 'left' | 'right';
  alt?: string;             // Accessibility label for icon-only buttons
  className?: string;
  block?: boolean;          // Full-width button
  // Link-Properties (optional - wenn href gesetzt ist, wird als Link gerendert)
  href?: string;
  target?: string;
  rel?: string;
}
```

**Beispiele:**

**Standard Buttons:**

```tsx
import { KernButton } from './components/kern';

function MyComponent() {
  return (
    <div>
      <KernButton 
        label="Primär" 
        variant="primary" 
        onClick={() => console.log('Clicked!')} 
      />
      <KernButton 
        label="Mit Icon" 
        variant="secondary" 
        icon="arrow-forward" 
        iconPosition="right" 
      />
      <KernButton 
        label="Deaktiviert" 
        variant="tertiary" 
        disabled={true} 
      />
      <KernButton 
        label="Block Button" 
        variant="primary" 
        block={true} 
      />
      <KernButton 
        label="Erfolg" 
        variant="success" 
      />
      <KernButton 
        label="Warnung" 
        variant="warning" 
      />
      <KernButton 
        label="Gefahr" 
        variant="danger" 
      />
    </div>
  );
}
```

**Button als Link:**

```tsx
import { KernButton } from './components/kern';

function MyComponent() {
  return (
    <div>
      {/* Externer Link */}
      <KernButton
        label="Zur KERN Website"
        variant="tertiary"
        href="https://www.kern-ux.de"
        target="_blank"
        rel="noopener"
        icon="arrow-forward"
        iconPosition="right"
      />
    
      {/* Interner Link */}
      <KernButton
        label="Zur Startseite"
        variant="secondary"
        href="/home"
      />
    </div>
  );
}
```

**Icon-Only Button:**

```tsx
import { KernButton } from './components/kern';

function MyComponent() {
  return (
    <KernButton 
      label="" 
      icon="add" 
      alt="Hinzufügen" 
      variant="primary" 
    />
  );
}
```

**Hinweis:** Wenn die `href`-Property gesetzt ist, wird der Button automatisch als `<a>`-Tag gerendert. Ohne `href` wird ein `<button>`-Tag verwendet.

### KernCard

Eine Karte zur Darstellung von Inhalten mit optionalem Bild, Titel und Footer.

**Props:**

```typescript
interface KernCardProps {
  title: string;
  preline?: string;
  subline?: string;
  img?: string;
  altText?: string;
  children: ReactNode;      // Card body content
  footer?: ReactNode;
  interactive?: boolean;    // Hover-Effekte für klickbare Karten
  size?: 'small' | 'large';
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernCard, KernButton } from './components/kern';

function MyComponent() {
  return (
    <KernCard
      title="Karten-Titel"
      preline="Überschrift"
      subline="Untertitel"
      img="/pfad/zu/bild.jpg"
      altText="Beschreibung des Bildes"
      footer={
        <KernButton label="Mehr erfahren" variant="primary" />
      }
    >
      <p>Hier steht der Hauptinhalt der Karte.</p>
      <p>Weitere Informationen...</p>
    </KernCard>
  );
}
```

**Interaktive Karte:**

```tsx
import { KernCard } from './components/kern';

function MyComponent() {
  return (
    <KernCard
      title="Klickbare Karte"
      interactive={true}
      size="small"
    >
      <p>Diese Karte reagiert auf Hover-Events.</p>
    </KernCard>
  );
}
```

### KernHeading

Überschriften in verschiedenen Größen mit semantisch korrekter HTML-Struktur.

**Props:**

```typescript
interface KernHeadingProps {
  children: ReactNode;
  level: 1 | 2 | 3 | 4 | 5 | 6;
  size?: 'display' | 'x-large' | 'large' | 'medium' | 'small';
}
```

**Standard-Größen nach Level:**

- Level 1: `display` (Standard)
- Level 2: `x-large` (Standard)
- Level 3: `large` (Standard)
- Level 4: `medium` (Standard)
- Level 5: `small` (Standard)
- Level 6: `small` (Standard)

**Beispiele:**

```tsx
import { KernHeading } from './components/kern';

function MyComponent() {
  return (
    <div>
      {/* Standard-Größen */}
      <KernHeading level={1}>Hauptüberschrift (display)</KernHeading>
      <KernHeading level={2}>Unterüberschrift (x-large)</KernHeading>
      <KernHeading level={3}>Abschnittsüberschrift (large)</KernHeading>
    
      {/* Benutzerdefinierte Größen */}
      <KernHeading level={1} size="large">
        Level 1 mit großer Schrift
      </KernHeading>
      <KernHeading level={4} size="x-large">
        Level 4 mit extra großer Schrift
      </KernHeading>
      <KernHeading level={2} size="small">
        Level 2 mit kleiner Schrift
      </KernHeading>
    </div>
  );
}
```

### KernText

Textkomponente für verschiedene Texttypen und -größen.

**Props:**

```typescript
interface KernTextProps {
  children: ReactNode;
  type?: 'title' | 'preline' | 'subline' | 'label' | 'body';
  size?: 'large' | 'small';
  bold?: boolean;           // Nur mit type="body" erlaubt
  muted?: boolean;          // Nur mit type="body" erlaubt
  component?: ElementType;  // Custom HTML-Element (Standard: 'p')
  className?: string;
}
```

**Verfügbare Text-Typen:**

- `title` - Für Titel und Hauptüberschriften
- `preline` - Für Vorspann-Text (oberhalb des Haupttitels)
- `subline` - Für Untertitel (unterhalb des Haupttitels)
- `label` - Für Label-Text und Beschriftungen
- `body` - Für Fließtext (Standard)

**Beispiele:**

```tsx
import { KernText } from './components/kern';

function MyComponent() {
  return (
    <div>
      {/* Verschiedene Text-Typen */}
      <KernText type="preline">Preline Text</KernText>
      <KernText type="title">Titel</KernText>
      <KernText type="subline">Untertitel</KernText>
      <KernText type="label">Label-Text</KernText>
      <KernText type="body">Standard Fließtext</KernText>
    
      {/* Mit Größen-Modifikatoren */}
      <KernText type="body" size="large">
        Großer Fließtext
      </KernText>
      <KernText type="label" size="small">
        Kleiner Label-Text
      </KernText>
      
      {/* Bold und Muted (nur mit body) */}
      <KernText type="body" bold>
        Fetter Text
      </KernText>
      <KernText type="body" muted>
        Gedämpfter Text
      </KernText>
      
      {/* Custom HTML-Element */}
      <KernText component="span" type="label">
        Als Span gerendert
      </KernText>
    </div>
  );
}
```

### KernLink

Verlinkungskomponente mit verschiedenen Stilen.

**Props:**

```typescript
interface KernLinkProps {
  href?: string;
  label?: string;           // Link text (alternative to children)
  children?: ReactNode;
  target?: '_blank' | '_self' | '_parent' | '_top';
  onClick?: () => void;
  icon?: KernIconType;
  small?: boolean;          // Kleinere Schriftgröße
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernLink } from './components/kern';

function MyComponent() {
  return (
    <div>
      <KernLink href="https://www.kern-ux.de" target="_blank" label="Externer Link" />
      <KernLink href="https://www.kern-ux.de" target="_blank">
        Externer Link mit Children
      </KernLink>
      <KernLink onClick={() => console.log('Clicked!')} label="Klickbarer Link" />
      <KernLink href="/seite" icon="arrow-forward" label="Link mit Icon" />
      <KernLink href="/seite" small label="Kleiner Link" />
    </div>
  );
}
```

### KernList

Eine flexible Listen-Komponente für einfache, Bullet- und nummerierte Listen.

**Props:**

```typescript
interface KernListItem {
  content: ReactNode;
  className?: string;
  id?: string;
}

interface KernListProps {
  items: KernListItem[];
  type?: 'simple' | 'bullet' | 'number';   // Standard: 'simple'
  size?: 'small' | 'medium' | 'large';     // Standard: 'medium'
  start?: number;                          // Startnummer für nummerierte Listen
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernList, KernText, KernLink } from './components/kern';

function MyComponent() {
  // Einfache Liste
  const simpleItems = [
    { content: 'Erstes Element' },
    { content: 'Zweites Element' },
    { content: 'Drittes Element' }
  ];
  
  // Liste mit Rich Content
  const richItems = [
    { content: <KernText>Einfacher Text</KernText> },
    { content: <KernLink href="https://example.com" label="Ein Link" /> },
    { content: <KernText bold>Fetter Text</KernText> }
  ];

  return (
    <div>
      {/* Einfache Liste ohne Bullets */}
      <KernList items={simpleItems} type="simple" />
      
      {/* Bullet-Liste */}
      <KernList items={simpleItems} type="bullet" />
      
      {/* Nummerierte Liste */}
      <KernList items={richItems} type="number" />
      
      {/* Nummerierte Liste mit Startpunkt */}
      <KernList items={simpleItems} type="number" start={5} />
      
      {/* Große Bullet-Liste */}
      <KernList items={simpleItems} type="bullet" size="large" />
    </div>
  );
}
```

### KernSpace

Eine Utility-Komponente für konsistente Abstände gemäß dem KERN Design-System.

**Props:**

```typescript
interface KernSpaceProps {
  size?: '2x-small' | 'x-small' | 'small' | 'default' | 'large' | 'x-large';
  debug?: boolean;           // Visualisierung des Abstands
  className?: string;
  children?: ReactNode;
}
```

**Verfügbare Größen:**

- `2x-small` - 2px Abstand (--kern-metric-space-2x-small)
- `x-small` - 4px Abstand (--kern-metric-space-x-small)
- `small` - 8px Abstand (--kern-metric-space-small)
- `default` - 16px Abstand (--kern-metric-space-default) - Standard
- `large` - 24px Abstand (--kern-metric-space-large)
- `x-large` - 32px Abstand (--kern-metric-space-x-large)

**Beispiele:**

```tsx
import { KernSpace, KernText } from './components/kern';

function MyComponent() {
  return (
    <div>
      <KernText>Erster Textblock</KernText>
      
      {/* Kleiner Abstand */}
      <KernSpace size="small" />
      
      <KernText>Zweiter Textblock</KernText>
      
      {/* Mittlerer Abstand (Standard) */}
      <KernSpace size="default" />
      
      <KernText>Dritter Textblock</KernText>
      
      {/* Großer Abstand */}
      <KernSpace size="large" />
      
      <KernText>Vierter Textblock</KernText>
      
      {/* Debug-Modus zur Visualisierung */}
      <KernSpace size="x-large" debug />
      
      <KernText>Text nach Debug-Space</KernText>
    </div>
  );
}
```

**Layout-Beispiel:**

```tsx
import { KernSpace, KernText, KernHeading } from './components/kern';

function PageLayout() {
  return (
    <div>
      <KernHeading level={1}>Seitentitel</KernHeading>
      <KernSpace size="large" />
      
      <KernHeading level={2}>Abschnitt 1</KernHeading>
      <KernSpace size="small" />
      <KernText>Inhalt des ersten Abschnitts.</KernText>
      
      <KernSpace size="default" />
      
      <KernHeading level={2}>Abschnitt 2</KernHeading>
      <KernSpace size="small" />
      <KernText>Inhalt des zweiten Abschnitts.</KernText>
    </div>
  );
}
```

## Formular-Komponenten

### KernForm

Container für Formulare mit Validierung und Wert-Extraktion.

**Props:**

```typescript
interface KernFormProps {
  children: ReactNode;
  onSubmit?: (event: FormEvent<HTMLFormElement>) => void;
  className?: string;
}

interface KernFormMethods {
  checkValidity(): boolean;
  reportValidity(): boolean;
  getValues(): Record<string, FormDataEntryValue>;
}
```

**Beispiel:**

```tsx
import { useRef } from 'react';
import { KernForm, KernInput, KernButton } from './components/kern';
import type { KernFormMethods } from './components/kern/KernForm';

function MyFormComponent() {
  const formRef = useRef<KernFormMethods>(null);

  const handleSubmit = () => {
    if (formRef.current) {
      const isValid = formRef.current.checkValidity();
      if (isValid) {
        const values = formRef.current.getValues();
        console.log('Form values:', values);
      }
    }
  };

  return (
    <KernForm ref={formRef}>
      <KernInput id="email" label="E-Mail" type="email" required />
      <KernInput id="name" label="Name" required />
      <KernButton label="Absenden" onClick={handleSubmit} />
    </KernForm>
  );
}
```

### KernInput

Eingabefeld mit verschiedenen Typen und Validierung.

**Props:**

```typescript
interface KernInputProps {
  id: string;
  label: string;
  type?: 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'search';
  value?: string | number;
  defaultValue?: string | number;
  name?: string;
  required?: boolean;
  disabled?: boolean;
  readonly?: boolean;
  hint?: string;
  error?: string;
  autoFocus?: boolean;
  onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
}
```

**Beispiel:**

```tsx
import { useState } from 'react';
import { KernInput } from './components/kern';

function MyComponent() {
  const [email, setEmail] = useState('');
  const [error, setError] = useState('');

  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    setEmail(e.target.value);
    if (error) setError('');
  };

  return (
    <div>
      <KernInput
        id="email"
        label="E-Mail-Adresse"
        type="email"
        value={email}
        onChange={handleChange}
        required
        hint="Bitte geben Sie eine gültige E-Mail-Adresse ein"
        error={error}
      />
      <KernInput
        id="password"
        label="Passwort"
        type="password"
        required
        hint="Mindestens 8 Zeichen"
      />
    </div>
  );
}
```

### KernSelect

Auswahlfeld mit Optionen.

**Props:**

```typescript
interface KernSelectProps {
  id: string;
  label: string;
  name?: string;
  required?: boolean;
  disabled?: boolean;
  hint?: string;
  error?: string;
  children: ReactNode;
}
```

**Beispiel:**

```tsx
import { KernSelect } from './components/kern';

function MyComponent() {
  return (
    <KernSelect
      id="country"
      label="Land auswählen"
      name="country"
      required
      hint="Wählen Sie Ihr Land aus"
    >
      <option value="">Bitte auswählen</option>
      <option value="de">Deutschland</option>
      <option value="at">Österreich</option>
      <option value="ch">Schweiz</option>
    </KernSelect>
  );
}
```

### KernTextarea

Mehrzeiliges Textfeld.

**Props:**

```typescript
interface KernTextareaProps {
  id: string;
  label: string;
  name?: string;
  value?: string;
  defaultValue?: string;
  required?: boolean;
  disabled?: boolean;
  readonly?: boolean;
  rows?: number;
  cols?: number;
  hint?: string;
  error?: string;
  onChange?: (event: React.ChangeEvent<HTMLTextAreaElement>) => void;
}
```

**Beispiel:**

```tsx
import { KernTextarea } from './components/kern';

function MyComponent() {
  return (
    <KernTextarea
      id="description"
      label="Beschreibung"
      name="description"
      rows={4}
      hint="Beschreiben Sie Ihr Anliegen (max. 500 Zeichen)"
      required
    />
  );
}
```

### KernCheckbox

Checkbox-Komponente für Ja/Nein-Entscheidungen.

**Props:**

```typescript
interface KernCheckboxProps {
  id: string;
  label: string;
  name?: string;
  checked?: boolean;
  defaultChecked?: boolean;
  required?: boolean;
  disabled?: boolean;
  onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
}
```

**Beispiel:**

```tsx
import { useState } from 'react';
import { KernCheckbox } from './components/kern';

function MyComponent() {
  const [accepted, setAccepted] = useState(false);

  return (
    <div>
      <KernCheckbox
        id="terms"
        label="Ich akzeptiere die Nutzungsbedingungen"
        checked={accepted}
        onChange={(e) => setAccepted(e.target.checked)}
        required
      />
      <KernCheckbox
        id="newsletter"
        label="Ich möchte den Newsletter erhalten"
        defaultChecked={false}
      />
    </div>
  );
}
```

### KernRadioGroup

Gruppe von Radio-Buttons für die Auswahl einer Option.

**Props:**

```typescript
interface KernRadioGroupItem {
  id?: string;
  value?: string;
  label: string;
  disabled?: boolean;
}

interface KernRadioGroupProps {
  name: string;
  legend?: string;
  items: KernRadioGroupItem[];
  selected?: string;
  onChange?: (value: string, event: FormEvent) => void;
  optional?: boolean;
  horizontal?: boolean;      // Horizontale Anordnung
  hint?: string;
  errorMessage?: string;
  autoFocus?: boolean;
  className?: string;
}
```

**Beispiel:**

```tsx
import { useState } from 'react';
import { KernRadioGroup } from './components/kern';

function MyComponent() {
  const [selectedSize, setSelectedSize] = useState('medium');
  const [selectedOption, setSelectedOption] = useState('');

  return (
    <div>
      {/* Einfache Radio-Gruppe */}
      <KernRadioGroup
        name="size"
        legend="Größe auswählen"
        items={[
          { label: 'Klein', value: 'small' },
          { label: 'Medium', value: 'medium' },
          { label: 'Groß', value: 'large' }
        ]}
        selected={selectedSize}
        onChange={(value) => setSelectedSize(value)}
      />
      
      {/* Horizontale Anordnung */}
      <KernRadioGroup
        name="gender"
        legend="Geschlecht"
        horizontal
        items={[
          { label: 'Männlich', value: 'm' },
          { label: 'Weiblich', value: 'w' },
          { label: 'Divers', value: 'd' }
        ]}
        selected={selectedOption}
        onChange={(value) => setSelectedOption(value)}
      />
      
      {/* Mit Hint und Optional */}
      <KernRadioGroup
        name="contact"
        legend="Bevorzugte Kontaktart"
        optional
        hint="Wählen Sie Ihre bevorzugte Kontaktmethode"
        items={[
          { label: 'E-Mail', value: 'email' },
          { label: 'Telefon', value: 'phone' },
          { label: 'Post', value: 'mail', disabled: true }
        ]}
      />
    </div>
  );
}
```

## Layout-Komponenten

### KernContainer

Container für die Seitenbreite und Zentrierung.

**Props:**

```typescript
interface KernContainerProps {
  children: ReactNode;
  fluid?: boolean;           // Volle Breite ohne max-width
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernContainer, KernRow, KernColumn } from './components/kern';

function MyComponent() {
  return (
    <div>
      {/* Standard Container mit max-width */}
      <KernContainer>
        <KernRow>
          <KernColumn>
            <h1>Hauptinhalt</h1>
            <p>Inhalt wird automatisch zentriert und begrenzt.</p>
          </KernColumn>
        </KernRow>
      </KernContainer>
      
      {/* Fluid Container - volle Breite */}
      <KernContainer fluid>
        <KernRow>
          <KernColumn>
            <p>Volle Breite ohne Begrenzung</p>
          </KernColumn>
        </KernRow>
      </KernContainer>
    </div>
  );
}
```

### KernRow / KernColumn

Grid-System für responsive Layouts.

**Props:**

```typescript
interface KernRowProps {
  children: ReactNode;
  align?: 'start' | 'center' | 'end';
  justify?: 'start' | 'center' | 'end' | 'around' | 'between' | 'evenly';
  className?: string;
}

interface KernColumnProps {
  children: ReactNode;
  align?: 'start' | 'center' | 'end';
  justify?: 'start' | 'center' | 'end' | 'around' | 'between' | 'evenly';
  sizes?: { xs?: number; sm?: number; md?: number; lg?: number; xl?: number; xxl?: number } | number;
  offsets?: { xs?: number; sm?: number; md?: number; lg?: number; xl?: number; xxl?: number } | number;
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernContainer, KernRow, KernColumn, KernText } from './components/kern';

function MyComponent() {
  return (
    <KernContainer>
      {/* Einfaches Zwei-Spalten-Layout */}
      <KernRow>
        <KernColumn sizes={{ md: 6 }}>
          <h2>Linke Spalte</h2>
          <p>Inhalt der linken Spalte</p>
        </KernColumn>
        <KernColumn sizes={{ md: 6 }}>
          <h2>Rechte Spalte</h2>
          <p>Inhalt der rechten Spalte</p>
        </KernColumn>
      </KernRow>
      
      {/* Mit Ausrichtung */}
      <KernRow justify="between" align="center">
        <KernColumn sizes={{ md: 2 }}>
          <KernText>Links</KernText>
        </KernColumn>
        <KernColumn sizes={{ md: 2 }}>
          <KernText>Rechts</KernText>
        </KernColumn>
      </KernRow>
      
      {/* Mit Offset */}
      <KernRow>
        <KernColumn sizes={{ md: 6 }} offsets={{ md: 3 }}>
          <p>Zentrierte Spalte mit Offset</p>
        </KernColumn>
      </KernRow>
      
      {/* Responsive Spalten */}
      <KernRow>
        <KernColumn sizes={{ xs: 12, sm: 6, md: 4, lg: 3 }}>
          <p>Responsive Spalte</p>
        </KernColumn>
      </KernRow>
    </KernContainer>
  );
}
```

### KernAccordion

Ausklappbarer Inhaltsbereich mit Unterstützung für einzelne und gruppierte Accordions.

**Props:**

```typescript
interface KernAccordionItem {
  id?: string;
  title: string;
  body: ReactNode;
  defaultOpen?: boolean;
  className?: string;
}

interface KernAccordionProps {
  items: KernAccordionItem[];
  variant?: 'single' | 'group';   // Standard: 'group'
  className?: string;
}
```

**Beispiele:**

```tsx
import { KernAccordion } from './components/kern';

function MyComponent() {
  return (
    <div>
      {/* Einzelnes Accordion */}
      <KernAccordion
        variant="single"
        items={[
          {
            title: "Häufig gestellte Fragen",
            body: "Hier ist die Antwort auf die Frage.",
            defaultOpen: true
          }
        ]}
      />
      
      {/* Accordion-Gruppe */}
      <KernAccordion
        variant="group"
        items={[
          {
            title: "Abschnitt 1",
            body: "Inhalt des ersten Abschnitts."
          },
          {
            title: "Abschnitt 2",
            body: "Inhalt des zweiten Abschnitts."
          },
          {
            title: "Abschnitt 3",
            body: (
              <div>
                <p>Rich Content mit HTML</p>
                <ul>
                  <li>Liste Item 1</li>
                  <li>Liste Item 2</li>
                </ul>
              </div>
            )
          }
        ]}
      />
    </div>
  );
}
```

### KernDialog

Modaler Dialog mit konfigurierbaren Buttons.

**Props:**

```typescript
interface DialogContextValue {
  open: boolean;
  handleOpen: () => void;
  handleClose: () => void;
  title: string;
  setTitle: (title: string) => void;
  body: ReactNode;
  setBody: (body: ReactNode) => void;
  buttons: DialogButton[];
  setButtons: (buttons: DialogButton[]) => void;
  openModal: (title: string, body: ReactNode, buttons: LegacyDialogButton[]) => void;
}

interface LegacyDialogButton {
  id: string;
  name: string;
  primary?: boolean;
  callback?: () => Promise<boolean | void> | boolean | void;
}
```

**Beispiel:**

```tsx
import { DialogProvider } from './components/addons/DialogContext';
import { useDialog } from './components/addons/useDialog';
import { KernButton } from './components/kern';

function MyDialogComponent() {
  const dialogContext = useDialog();

  if (!dialogContext) return null;

  const { openModal } = dialogContext;

  const showConfirmDialog = () => {
    openModal(
      "Bestätigung erforderlich",
      <p>Möchten Sie diese Aktion wirklich ausführen?</p>,
      [
        { id: "cancel", name: "Abbrechen" },
        { 
          id: "confirm", 
          name: "Bestätigen", 
          primary: true,
          callback: () => {
            console.log("Bestätigt!");
            return true; // Dialog schließen
          }
        }
      ]
    );
  };

  return (
    <KernButton label="Dialog öffnen" onClick={showConfirmDialog} />
  );
}

function App() {
  return (
    <KernDialogProvider>
      <MyDialogComponent />
    </KernDialogProvider>
  );
}
```

## Daten-Komponenten

### KernTable

Tabelle für die Darstellung von strukturierten Daten.

**Props:**

```typescript
interface KernTableColumn {
  id?: string;
  label: string;
  numeric?: boolean;
  valueGetter?: (value: any) => string | number | boolean;
  valueFormatter?: (value: any) => ReactNode;
}

interface KernTableProps {
  title?: string;                            // Optionaler Tabellen-Titel
  columns: (string | KernTableColumn)[];     // Spalten-Definition
  rows: Array<Record<string, any>>;          // Zeilen-Daten
  footer?: Array<ReactNode>;                 // Optionale Fußzeile
  striped?: boolean;                         // Alternierende Zeilenfarben
  small?: boolean;                           // Kompakte Darstellung
  responsive?: boolean;                      // Responsive Tabelle
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernTable } from './components/kern';

function MyComponent() {
  const data = [
    { name: 'Max Mustermann', email: 'max@example.com', rolle: 'Admin' },
    { name: 'Anna Schmidt', email: 'anna@example.com', rolle: 'Benutzer' },
    { name: 'Tom Weber', email: 'tom@example.com', rolle: 'Moderator' }
  ];

  return (
    <KernTable
      title="Benutzerliste"
      columns={['name', 'email', 'rolle']}
      rows={data}
      striped
    />
  );
}
```

**Mit komplexen Spalten-Definitionen:**

```tsx
import { KernTable } from './components/kern';

function MyComponent() {
  const columns = [
    { id: 'id', label: '#', numeric: true },
    { id: 'product', label: 'Produktname' },
    { 
      id: 'price', 
      label: 'Preis', 
      numeric: true,
      valueFormatter: (value) => `${value.toFixed(2)} €` 
    },
    { id: 'status', label: 'Status' }
  ];

  const rows = [
    { id: 1, product: 'Laptop', price: 1299.99, status: 'Verfügbar' },
    { id: 2, product: 'Maus', price: 29.99, status: 'Verfügbar' }
  ];

  return (
    <KernTable
      title="Produktübersicht"
      columns={columns}
      rows={rows}
      striped
      responsive
    />
  );
}
```

### KernTaskList

Liste von Aufgaben mit Status-Badges.

**Props:**

```typescript
interface KernTaskListItem {
  number?: number;
  label: string;
  badge?: KernBadgeProps;
  onClick?: () => void;
}

interface KernTaskListProps {
  title?: string;
  items: KernTaskListItem[];
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernTaskList } from './components/kern';

function MyComponent() {
  const tasks = [
    { 
      number: 1, 
      label: "Persönliche Daten eingeben",
      badge: { label: "Abgeschlossen", variant: "success" },
      onClick: () => console.log('Task 1 clicked')
    },
    { 
      number: 2, 
      label: "Dokumente hochladen",
      badge: { label: "In Bearbeitung", variant: "warning" }
    },
    { 
      number: 3, 
      label: "Bestätigung abwarten",
      badge: { label: "Ausstehend", variant: "info" }
    }
  ];

  return (
    <KernTaskList
      title="Anmeldung"
      items={tasks}
    />
  );
}
```

### KernAlert

Hinweis- und Warnmeldungen mit verschiedenen Status-Varianten.

**Props:**

```typescript
interface KernAlertProps {
  title: string;
  variant: 'info' | 'success' | 'warning' | 'danger';
  children?: ReactNode;      // Optionaler Body-Text
  linkText?: string;         // Text für optionalen Link
  linkHref?: string;         // URL für optionalen Link
  linkIcon?: KernIconType;   // Icon für optionalen Link
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernAlert } from './components/kern';

function MyComponent() {
  return (
    <div>
      <KernAlert 
        variant="success" 
        title="Erfolg!"
      >
        Ihre Daten wurden erfolgreich gespeichert.
      </KernAlert>
    
      <KernAlert variant="warning" title="Achtung">
        Bitte überprüfen Sie Ihre Eingaben.
      </KernAlert>
    
      <KernAlert variant="danger" title="Fehler">
        Ein Fehler ist aufgetreten. Bitte versuchen Sie es erneut.
      </KernAlert>
      
      <KernAlert 
        variant="info" 
        title="Hinweis"
        linkText="Mehr erfahren"
        linkHref="/hilfe"
        linkIcon="arrow-forward"
      >
        Weitere Informationen finden Sie in der Hilfe.
      </KernAlert>
    </div>
  );
}
```

### KernDescriptionList

Eine Komponente zur Darstellung von Begriffen und deren Definitionen.

**Props:**

```typescript
interface KernDescriptionListProps {
  details: Record<string, ReactNode | Date | File | object>;
  columns?: boolean;                                              // Spalten-Layout
  formatKey?: (key: string) => string;                            // Key-Formatierung
  formatValue?: (key: string, value: any) => ReactNode;           // Value-Formatierung
  ignoredDetailKeys?: string[];                                   // Auszuschließende Keys
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernDescriptionList } from './components/kern';

function MyComponent() {
  const details = {
    "Name": "Max Mustermann",
    "E-Mail": "max@example.com",
    "Registriert": new Date("2024-01-15"),
    "Status": "Aktiv"
  };

  return (
    <div>
      {/* Standard-Layout */}
      <KernDescriptionList details={details} />
      
      {/* Spalten-Layout */}
      <KernDescriptionList details={details} columns />
      
      {/* Mit Key-Formatierung */}
      <KernDescriptionList 
        details={details} 
        formatKey={(key) => key.toUpperCase()}
      />
      
      {/* Mit ausgeschlossenen Keys */}
      <KernDescriptionList 
        details={details} 
        ignoredDetailKeys={["Status"]}
      />
    </div>
  );
}
```

### KernSummary

Eine Komponente zur Darstellung von Zusammenfassungen mit Bearbeitungslinks.

**Props:**

```typescript
interface KernSummaryProps {
  number?: number;                                         // Optionale Nummerierung
  label?: string;                                          // Abschnitts-Titel
  showHeader?: boolean;                                    // Header anzeigen (Standard: true)
  actions?: KernLinkProps[];                               // Aktions-Links (z.B. "Bearbeiten")
  descriptionList?: KernDescriptionListProps;              // Volle Kontrolle über Description List
  details?: Record<string, any>;                           // Direkte Details (vereinfacht)
  formatKey?: (key: string) => string;                     // Key-Formatierung
  children?: ReactNode;                                    // Custom Content
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernSummary } from './components/kern';

function MyComponent() {
  return (
    <div>
      {/* Mit Details */}
      <KernSummary
        number={1}
        label="Persönliche Daten"
        details={{
          "Vorname": "Max",
          "Nachname": "Mustermann",
          "E-Mail": "max@example.com"
        }}
        actions={[
          { href: "#edit", label: "Bearbeiten", icon: "edit" }
        ]}
      />
      
      {/* Mit descriptionList für volle Kontrolle */}
      <KernSummary
        number={2}
        label="Adressdaten"
        descriptionList={{
          details: {
            "Straße": "Musterstraße 1",
            "PLZ": "12345",
            "Stadt": "Musterstadt"
          },
          columns: true
        }}
        actions={[
          { href: "#edit", label: "Bearbeiten" }
        ]}
      />
      
      {/* Mit Custom Children */}
      <KernSummary
        label="Übersicht"
        showHeader={true}
      >
        <p>Custom Content hier</p>
      </KernSummary>
    </div>
  );
}
```

## Zusätzliche Komponenten

### KernBadge

Eine Komponente zur Darstellung von Status-Badges.

**Props:**

```typescript
interface KernBadgeProps {
  label: string;
  variant: 'info' | 'success' | 'warning' | 'danger';
  withIcon?: boolean;        // Icon entsprechend der Variante anzeigen
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernBadge } from './components/kern';

function MyComponent() {
  return (
    <div>
      <KernBadge label="Info" variant="info" />
      <KernBadge label="Erfolg" variant="success" withIcon />
      <KernBadge label="Warnung" variant="warning" withIcon />
      <KernBadge label="Fehler" variant="danger" withIcon />
    </div>
  );
}
```

### KernIcon

Eine Komponente zur Darstellung von Icons.

**Props:**

```typescript
interface KernIconProps {
  icon: KernIconType;
  size?: 'small' | 'medium' | 'large';   // Standard: 'small'
  className?: string;
}
```

**Verfügbare Icon-Typen:**

```typescript
type KernIconType = 
  | 'home' | 'arrow-up' | 'arrow-down' | 'arrow-forward' | 'arrow-back'
  | 'info' | 'success' | 'warning' | 'danger'
  | 'open-in-new' | 'download' | 'logout' | 'checklist' | 'mail' | 'edit'
  | 'sign-language' | 'easy-language' | 'autorenew' | 'add' | 'close' | 'delete'
  | 'search' | 'question-mark' | 'more-vert' | 'content-copy'
  | 'visibility' | 'visibility-off' | 'check' | 'drive-folder-upload'
  | 'chevron-left' | 'chevron-right'
  | 'keyboard-double-arrow-left' | 'keyboard-double-arrow-right';
```

**Beispiel:**

```tsx
import { KernIcon } from './components/kern';

function MyComponent() {
  return (
    <div>
      <KernIcon icon="home" size="small" />
      <KernIcon icon="mail" size="medium" />
      <KernIcon icon="arrow-forward" size="large" />
      <KernIcon icon="check" />
      <KernIcon icon="download" />
    </div>
  );
}
```

### KernLoader

Eine Komponente zur Darstellung von Ladeanimationen.

**Props:**

```typescript
interface KernLoaderProps {
  // Keine Props erforderlich
}
```

**Beispiel:**

```tsx
import { KernLoader } from './components/kern';

function MyComponent() {
  return (
    <div>
      <KernLoader />
    </div>
  );
}
```

### KernKopfzeile

Die Kopfzeile identifiziert digitale Präsenzen der öffentlichen Verwaltung.

**Props:**

```typescript
interface KernKopfzeileProps {
  label: string;
  icon?: ReactNode;         // Optionales Icon/Flagge
  fluid?: boolean;          // Volle Breite
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernKopfzeile } from './components/kern';

function MyComponent() {
  return (
    <div>
      {/* Einfache Kopfzeile */}
      <KernKopfzeile label="Bundesministerium für Digitales" />
      
      {/* Mit Icon */}
      <KernKopfzeile 
        label="Bundesrepublik Deutschland"
        icon={<img src="/flagge.svg" alt="" />}
      />
      
      {/* Fluid (volle Breite) */}
      <KernKopfzeile 
        label="Onlineservice Portal"
        fluid
      />
    </div>
  );
}
```

### KernProgress

Eine Komponente zur Darstellung von Fortschrittsbalken.

**Props:**

```typescript
interface KernProgressProps {
  value: number;
  max: number;
  label?: string;
  labelPosition?: 'top' | 'bottom';   // Standard: 'top'
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernProgress } from './components/kern';

function MyComponent() {
  return (
    <div>
      <KernProgress value={2} max={5} label="Schritt 2 von 5" />
      <KernProgress value={75} max={100} label="75% abgeschlossen" labelPosition="bottom" />
    </div>
  );
}
```

### KernDivider

Eine Komponente zur Darstellung von Trennlinien.

**Props:**

```typescript
interface KernDividerProps {
  spacing?: 'none' | '2x-small' | 'x-small' | 'small' | 'default' | 'large' | 'x-large';
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernDivider, KernText } from './components/kern';

function MyComponent() {
  return (
    <div>
      <KernText>Abschnitt 1</KernText>
      <KernDivider spacing="large" />
      <KernText>Abschnitt 2</KernText>
      <KernDivider spacing="default" />
      <KernText>Abschnitt 3</KernText>
    </div>
  );
}
```

### KernInputDate

Eine Komponente für Datumseingaben.

**Props:**

```typescript
interface KernInputDateProps {
  id: string;
  label: string;
  value?: string;
  onChange?: (value: string) => void;
  required?: boolean;
  disabled?: boolean;
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernInputDate } from './components/kern';

function MyComponent() {
  return (
    <KernInputDate
      id="birthdate"
      label="Geburtsdatum"
      onChange={(value) => console.log(value)}
    />
  );
}
```

### KernFieldset

Eine Komponente für Formular-Fieldsets.

**Props:**

```typescript
interface KernFieldsetProps {
  label?: string;
  hint?: string;
  error?: string;
  orientation?: 'vertical' | 'horizontal';
  children: ReactNode;
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernFieldset, KernInput, KernCheckbox } from './components/kern';

function MyComponent() {
  return (
    <div>
      {/* Vertikales Fieldset */}
      <KernFieldset label="Persönliche Daten">
        <KernInput id="name" label="Name" />
        <KernInput id="email" label="E-Mail" type="email" />
      </KernFieldset>
      
      {/* Horizontales Fieldset mit Checkboxen */}
      <KernFieldset 
        label="Optionen auswählen" 
        orientation="horizontal"
        hint="Wählen Sie alle zutreffenden Optionen"
      >
        <KernCheckbox id="opt1" label="Option 1" />
        <KernCheckbox id="opt2" label="Option 2" />
        <KernCheckbox id="opt3" label="Option 3" />
      </KernFieldset>
      
      {/* Mit Fehler */}
      <KernFieldset 
        label="Pflichtangaben" 
        error="Bitte füllen Sie alle Pflichtfelder aus"
      >
        <KernInput id="required1" label="Feld 1" required />
        <KernInput id="required2" label="Feld 2" required />
      </KernFieldset>
    </div>
  );
}
```

### KernSidebar / KernSidebarItem

Eine Komponente für Seitenleisten-Navigation.

**Props:**

```typescript
interface KernSidebarItemProps {
  children: ReactNode;
  className?: string;
}

// KernSidebar erwartet KernSidebarItem als Kinder
```

**Beispiel:**

```tsx
import { KernSidebar, KernSidebarItem } from './components/addons';
import { KernLink } from './components/kern';

function MyComponent() {
  return (
    <KernSidebar>
      <KernSidebarItem>
        <KernLink href="/home" label="Startseite" />
      </KernSidebarItem>
      <KernSidebarItem>
        <KernLink href="/about" label="Über uns" />
      </KernSidebarItem>
      <KernSidebarItem>
        <KernLink href="/contact" label="Kontakt" />
      </KernSidebarItem>
    </KernSidebar>
  );
}
```

### KernToggleDarkMode

Eine Komponente zum Umschalten zwischen Hell- und Dunkelmodus.

**Props:**

```typescript
interface KernToggleDarkModeProps {
  className?: string;
}
```

**Beispiel:**

```tsx
import { KernToggleDarkMode } from './components/addons';

function MyComponent() {
  return (
    <div>
      <KernToggleDarkMode />
    </div>
  );
}
```

### KernDialogProvider & useDialog

Dialog-Kontext und Hook für modale Dialoge.

**useDialog Hook:**

```typescript
interface KernLegacyDialogButton {
  id: string;
  name: string;
  primary?: boolean;
  callback?: () => Promise<boolean | void> | boolean | void;
}

interface DialogContextValue {
  open: boolean;
  handleOpen: () => void;
  handleClose: () => void;
  title: string;
  setTitle: (title: string) => void;
  setBody: (body: ReactNode) => void;
  buttons: KernButtonProps[];
  setButtons: (buttons: KernButtonProps[]) => void;
  openModal: (title: string, body: ReactNode, buttons: KernLegacyDialogButton[]) => void;
}

const useDialog = (): DialogContextValue | null;
const useDialogSafe = (): DialogContextValue;  // Wirft Error wenn außerhalb von Provider
```

**Beispiel:**

```tsx
import { KernDialogProvider, useDialog } from './components/addons';
import { KernButton } from './components/kern';

function MyDialogComponent() {
  const dialog = useDialog();

  const openConfirmDialog = () => {
    dialog?.openModal(
      "Bestätigung",
      <p>Möchten Sie fortfahren?</p>,
      [
        { id: "cancel", name: "Abbrechen" },
        { 
          id: "confirm", 
          name: "Bestätigen", 
          primary: true,
          callback: () => {
            console.log("Bestätigt!");
            return true;  // Dialog schließen
          }
        }
      ]
    );
  };

  return (
    <KernButton label="Dialog öffnen" onClick={openConfirmDialog} />
  );
}

function App() {
  return (
    <KernDialogProvider>
      <MyDialogComponent />
    </KernDialogProvider>
  );
}
```

### KernTabs / KernTabList / KernTab / KernTabPanels / KernTabPanel

Tabs-System für die Organisation von Inhalten in Registerkarten.

**Props:**

```typescript
interface KernTabsProps {
  id: string;                              // Eindeutige ID für die Tab-Gruppe
  onTabChange?: (index: number) => void;   // Callback bei Tab-Wechsel
  children: ReactNode;
}

interface KernTabListProps {
  children: ReactNode;
  className?: string;
}

interface KernTabProps {
  children: ReactNode;
  className?: string;
}

interface KernTabPanelsProps {
  children: ReactNode;
}

interface KernTabPanelProps {
  children: ReactNode;
  className?: string;
}
```

**Beispiel:**

```tsx
import { useState } from 'react';
import { KernTabs, KernTabList, KernTab, KernTabPanels, KernTabPanel } from './components/addons';
import { KernText } from './components/kern';

function MyComponent() {
  const [activeIndex, setActiveIndex] = useState(0);

  return (
    <KernTabs id="my-tabs" onTabChange={(index) => setActiveIndex(index)}>
      <KernTabList>
        <KernTab>Abschnitt 1</KernTab>
        <KernTab>Abschnitt 2</KernTab>
        <KernTab>Abschnitt 3</KernTab>
      </KernTabList>
      <KernTabPanels>
        <KernTabPanel>
          <KernText>Inhalte für den ersten Abschnitt</KernText>
        </KernTabPanel>
        <KernTabPanel>
          <KernText>Inhalte für den zweiten Abschnitt</KernText>
        </KernTabPanel>
        <KernTabPanel>
          <KernText>Inhalte für den dritten Abschnitt</KernText>
        </KernTabPanel>
      </KernTabPanels>
    </KernTabs>
  );
}
```

### KernMenubar / KernMenu / KernSubMenu / KernMenuitem

Komponenten für Menüleisten und Dropdown-Menüs mit vollständiger Tastaturnavigation.

**Props:**

```typescript
interface KernMenubarProps {
  ariaLabel: string;            // Barrierefreie Beschreibung der Menüleiste
  children: ReactNode;
  className?: string;
}

interface KernMenuProps {
  ariaLabel: string;            // Barrierefreie Beschreibung des Menüs
  focusIndex: number;           // Index des zu fokussierenden Elements
  children: ReactNode;
  className?: string;
}

interface KernSubMenuProps {
  label: string;                // Text des Untermenü-Triggers
  children: ReactNode;
  className?: string;
}

interface KernMenuitemProps {
  children: ReactElement;       // Muss <a> oder <button> Element sein
}
```

**Beispiel Menubar:**

```tsx
import { KernMenubar, KernMenuitem, KernSubMenu } from './components/addons';

function Navigation() {
  return (
    <KernMenubar ariaLabel="Hauptnavigation">
      <KernMenuitem>
        <a href="/">Startseite</a>
      </KernMenuitem>
      <KernMenuitem>
        <a href="/about">Über uns</a>
      </KernMenuitem>
      <KernSubMenu label="Rechtshinweise">
        <KernMenuitem>
          <a href="/datenschutz">Datenschutzerklärung</a>
        </KernMenuitem>
        <KernMenuitem>
          <a href="/impressum">Impressum</a>
        </KernMenuitem>
      </KernSubMenu>
    </KernMenubar>
  );
}
```

**Beispiel Menu (Dropdown):**

```tsx
import { KernMenu, KernMenuitem } from './components/addons';

function DropdownMenu() {
  return (
    <KernMenu ariaLabel="Aktionen" focusIndex={0}>
      <KernMenuitem>
        <button onClick={() => alert('Neu')}>Neu</button>
      </KernMenuitem>
      <KernMenuitem>
        <button onClick={() => alert('Öffnen')}>Öffnen</button>
      </KernMenuitem>
      <KernMenuitem>
        <button onClick={() => alert('Speichern')}>Speichern</button>
      </KernMenuitem>
    </KernMenu>
  );
}
```

## Best Practices

### TypeScript-Nutzung

```tsx
// Immer Typen für Props definieren
interface MyComponentProps {
  title: string;
  count: number;
  items?: string[];
}

function MyComponent({ title, count, items = [] }: MyComponentProps) {
  // Implementation
}
```

### Formular-Validierung

```tsx
import { useRef, useState } from 'react';
import { KernForm, KernInput, KernButton } from './components/kern';
import type { KernFormMethods } from './components/kern/KernForm';

function ValidatedForm() {
  const formRef = useRef<KernFormMethods>(null);
  const [errors, setErrors] = useState<Record<string, string>>({});

  const validateForm = () => {
    const newErrors: Record<string, string> = {};
  
    if (formRef.current) {
      const values = formRef.current.getValues();
    
      if (!values?.get('email')) {
        newErrors.email = 'E-Mail ist erforderlich';
      }
    
      if (!values?.get('name')) {
        newErrors.name = 'Name ist erforderlich';
      }
    }
  
    setErrors(newErrors);
    return Object.keys(newErrors).length === 0;
  };

  const handleSubmit = () => {
    if (validateForm()) {
      // Form ist valide, Daten verarbeiten
      console.log('Form submitted successfully');
    }
  };

  return (
    <KernForm ref={formRef}>
      <KernInput
        id="name"
        label="Name"
        required
        error={errors.name}
      />
      <KernInput
        id="email"
        label="E-Mail"
        type="email"
        required
        error={errors.email}
      />
      <KernButton label="Absenden" onClick={handleSubmit} />
    </KernForm>
  );
}
```

### Responsive Design

```tsx
import { KernContainer, KernRow, KernColumn } from './components/kern';

function ResponsiveLayout() {
  return (
    <KernContainer>
      <KernRow>
        <KernColumn className="md:w-1/2 lg:w-1/3">
          <h2>Spalte 1</h2>
        </KernColumn>
        <KernColumn className="md:w-1/2 lg:w-1/3">
          <h2>Spalte 2</h2>
        </KernColumn>
        <KernColumn className="md:w-full lg:w-1/3">
          <h2>Spalte 3</h2>
        </KernColumn>
      </KernRow>
    </KernContainer>
  );
}
```

## Troubleshooting

### Häufige Probleme

1. **TypeScript-Fehler**: Stellen Sie sicher, dass alle erforderlichen Props übergeben werden
2. **Styling-Probleme**: Überprüfen Sie, ob die KERN-CSS-Dateien korrekt eingebunden sind
3. **Dialog-Kontext**: Verwenden Sie `DialogProvider` als Wrapper für Dialog-Funktionalität

### Performance-Tipps

- Verwenden Sie `useCallback` für Event-Handler in wiederverwendbaren Komponenten
- Nutzen Sie `useMemo` für aufwendige Berechnungen
- Vermeiden Sie unnötige Re-Renders durch korrekte Dependency-Arrays

### Accessibility

Alle KERN-Komponenten folgen den WCAG-Richtlinien:

- Korrekte ARIA-Labels und -Rollen
- Tastaturnavigation
- Ausreichende Farbkontraste
- Semantisch korrekte HTML-Struktur

## Weitere Ressourcen

- [Offizielle KERN-Dokumentation](https://www.kern-ux.de)
- [GitHub Repository](https://gitlab.opencode.de/kern-ux/community/kern-react-kit)
- [Contributing Guidelines](./CONTRIBUTING.md)
- [Changelog](./CHANGELOG.md)
