# RadioGroup

Eine RadioGroup ist ein Auswahlelement, das es dem User ermöglicht, genau eine Option aus einer vordefinierten Gruppe auszuwählen.

## Overview

# Playground

Verwende `<RadioGroup />` zusammen mit mehreren `<Radio />`, um eine RadioGroup
darzustellen. Über der RadioGroup kann ein beschreibendes
[Label](/04-components/content/label/overview) verwendet werden. Es kann
weggelassen werden, wenn die RadioGroup ohne verstanden wird oder wenn ein
anderes beschreibendes Element – wie eine
[Heading](/04-components/content/heading/overview) – in der Nähe platziert wird.
Wenn kein Label vorhanden ist, muss ein aria-label gesetzt werden.

```tsx
import {
  Label,
  Radio,
  RadioGroup,
} from "@mittwald/flow-react-components";

<RadioGroup defaultValue="admin">
  <Label>Rolle</Label>
  <Radio value="admin">Administrator</Radio>
  <Radio value="member">Mitglied</Radio>
  <Radio value="accountant">Buchhalter</Radio>
</RadioGroup>
```

---

# RadioButtons

RadioGroups können statt mit einfachen **Radios** auch mit **RadioButtons**
gefüllt werden. Ersetze dafür `<Radio />` mit `<RadioButton />`. Anders als
einfache Radios können RadioButtons mehr Inhalt – wie z. B. eine Überschrift mit
Text und Subtext – darstellen und dürfen auch nebeneinander gesetzt werden.

```tsx
import {
  Label,
  RadioButton,
  RadioGroup,
} from "@mittwald/flow-react-components";

<RadioGroup defaultValue="mysql">
  <Label>Datenbank-Typ</Label>
  <RadioButton value="mysql">MySQL</RadioButton>
  <RadioButton value="redis">Redis</RadioButton>
</RadioGroup>
```

## Weiterer Inhalt

Anstelle einer einfachen Bezeichnung kann der `<RadioButton />` auch mit
zusätzlichem Inhalt gefüllt werden. Verwende dazu innerhalb des
`<RadioButtons />` [Text](/04-components/content/text/overview) für eine
Überschrift und `<Content />` für Fließtext.

```tsx
import {
  Content,
  RadioButton,
  RadioGroup,
  Text,
} from "@mittwald/flow-react-components";

<RadioGroup
  defaultValue="bookDomain"
  aria-label="Domain"
  l={[1, 1]}
>
  <RadioButton value="bookDomain">
    <Text>Domain buchen</Text>
    <Content>
      Du hast eine Wunsch-Domain? Kein Problem, wir helfen
      dir, die passende Domain für dich zu finden.
      <br />
      <strong>
        <small>8,28€ jährlich</small>
      </strong>
    </Content>
  </RadioButton>
  <RadioButton value="moveDomain">
    <Text>Domain umziehen</Text>
    <Content>
      Du hast schon eine Domain und möchtest sie von deinem
      jetzigen Anbieter zu mittwald umziehen.
      <br />
      <strong>
        <small>8,28€ jährlich</small>
      </strong>
    </Content>
  </RadioButton>
  <RadioButton value="virtualHost">
    <Text>Virtual Host einrichten</Text>
    <Content>
      Die Domain bleibt bei deinem bisherigen Anbieter, du
      kannst sie aber für deine Website in unserem mStudio
      verwenden.
      <br />
      <strong>
        <small>kostenlos</small>
      </strong>
    </Content>
  </RadioButton>
  <RadioButton value="subdomain">
    <Text>Subdomain anlegen</Text>
    <Content>
      Eine Subdomain von einer bereits vorhandenen Domain
      erstellen, um sie für dein Projekt zu verwenden.
      <br />
      <strong>
        <small>kostenlos</small>
      </strong>
    </Content>
  </RadioButton>
</RadioGroup>
```

## Benutzerdefinierte Spalten

Die RadioGroup verwendet das
[ColumnLayout](/04-components/structure/column-layout/overview), um eine
Anpassung der Spalten zu ermöglichen. Bei der Verwendung von RadioButtons
entspricht der Default dem des ColumnLayouts, während Radios im Default
untereinander angezeigt werden.

```tsx
import {
  Label,
  RadioButton,
  RadioGroup,
} from "@mittwald/flow-react-components";

<RadioGroup
  defaultValue="one"
  s={[1, 1]}
  m={[1, 1, 1]}
  l={[1, 1, 1, 1]}
>
  <Label>Benutzerdefinierte Spalten</Label>
  <RadioButton value="one">Spalte 1</RadioButton>
  <RadioButton value="two">Spalte 2</RadioButton>
  <RadioButton value="three">Spalte 3</RadioButton>
</RadioGroup>
```

---

# Mit FieldDescription

Unterhalb der `<Radio />` oder `<RadioButton />` kann eine hilfreiche
`<FieldDescription />` eingebaut werden.

```tsx
import {
  FieldDescription,
  Label,
  Radio,
  RadioGroup,
} from "@mittwald/flow-react-components";

<RadioGroup defaultValue="more">
  <Label>Wie viele Pflanzen besitzt du?</Label>
  <Radio value="more">Mehr als 9 Pflanzen</Radio>
  <Radio value="6-8">6-8 Pflanzen</Radio>
  <Radio value="3-5">3-5 9 Pflanzen</Radio>
  <Radio value="1-2">1-2 Pflanzen</Radio>
  <Radio value="none">Keine</Radio>
  <FieldDescription>
    Mehrere identische Pflanzen in einem Topf gelten als
    eine Pflanze.
  </FieldDescription>
</RadioGroup>
```

---

# States

Eine RadioGroup hat 3 States: **Default**, **Disabled** und **Error**. Radios
und RadioButtons verfügen über die States **Default**, **Hover**, **Pressed**,
**Disabled**, **Focused** und **Selected**.

```tsx
import {
  RadioButton,
  RadioGroup,
} from "@mittwald/flow-react-components";

<RadioGroup
  defaultValue="selected"
  l={[1, 1]}
  aria-label="States"
>
  <RadioButton value="default">Domain buchen</RadioButton>
  <RadioButton value="selected">Domain buchen</RadioButton>
  <RadioButton isDisabled value="default">
    Domain buchen
  </RadioButton>
  <RadioButton isDisabled value="selected">
    Domain buchen
  </RadioButton>
</RadioGroup>
```

**Selected:** Wenn ein Radio/RadioButton vom User ausgewählt wird, erhält er den
State Selected. In einer RadioGroup kann sich immer nur ein Radio/RadioButton in
diesem State befinden. In den meisten Fällen ist es sinnvoll, zu Beginn eine
Option vorzuselektieren.

**Disabled:** Wenn die RadioGroup den State Disabled hat, erhalten alle
Radios/RadioButtons automatisch ebenfalls diesen State, sodass sie vom User
nicht ausgewählt werden können. Es ist auch möglich, einzelne
Radios/RadioButtons auf Disabled zu setzen.

```tsx
import {
  FieldError,
  Label,
  RadioButton,
  RadioGroup,
} from "@mittwald/flow-react-components";

<RadioGroup isInvalid>
  <Label>Datenbank-Typ</Label>
  <RadioButton value="mysql">MySQL</RadioButton>
  <RadioButton value="redis">Redis</RadioButton>
  <FieldError>Bitte wähle eine Option aus</FieldError>
</RadioGroup>
```

**Error:** Ein Error-State sollte angezeigt werden, wenn etwas schiefgelaufen
ist (siehe
[Fehlermeldungen](/02-foundations/03-content-guidelines/03-fehlermeldungen)). Da
häufig eine Option in der RadioGroup vorselektiert ist, wird das obige Beispiel
nur selten benötigt.

---

# Kombiniere mit ...

## ContextualHelp

Benutze die [ContextualHelp](/04-components/overlays/contextual-help/overview)
Komponente, wenn du weitere Informationen bereitstellen möchtest, und diese zu
lang für die FieldDescription sind.

```tsx
import {
  Button,
  ContextualHelp,
  ContextualHelpTrigger,
  Heading,
  Label,
  Radio,
  RadioGroup,
  Text,
} from "@mittwald/flow-react-components";

<RadioGroup defaultValue="more">
  <Label>
    Täglicher Kaffeekonsum
    <ContextualHelpTrigger>
      <Button />
      <ContextualHelp>
        <Heading>Weitere Informationen</Heading>
        <Text>
          Hier gibt es weitere Informationen, die zu lang
          für die FieldDescription sind.
        </Text>
      </ContextualHelp>
    </ContextualHelpTrigger>
  </Label>
  <Radio value="more">Mehr als 6 Tassen</Radio>
  <Radio value="5-6">5-6 Tassen</Radio>
  <Radio value="3-4">3-4 Tassen</Radio>
  <Radio value="1-2">1-2 Tassen</Radio>
  <Radio value="none">Trinke keinen Kaffee</Radio>
</RadioGroup>
```

## React Hook Form

```tsx
import {
  Label,
  Radio,
  RadioGroup,
  Section,
} from "@mittwald/flow-react-components";
import { useForm } from "react-hook-form";
import {
  Form,
  SubmitButton,
  typedField,
} from "@mittwald/flow-react-components/react-hook-form";
import { sleep } from "@/content/04-components/actions/action/examples/lib";

export default () => {
  const form = useForm<{ coffee: string }>({
    defaultValues: { coffee: "more" },
  });
  const Field = typedField(form);

  return (
    <Section>
      <Form form={form} onSubmit={sleep}>
        <Field
          name="coffee"
          rules={{
            required: "Bitte gib deinen Kaffeekonsum an",
          }}
        >
          <RadioGroup>
            <Label>Täglicher Kaffeekonsum</Label>
            <Radio value="more">Mehr als 6 Tassen</Radio>
            <Radio value="5-6">5-6 Tassen</Radio>
            <Radio value="3-4">3-4 Tassen</Radio>
            <Radio value="1-2">1-2 Tassen</Radio>
            <Radio value="none">Trinke keinen Kaffee</Radio>
          </RadioGroup>
        </Field>
        <SubmitButton>Speichern</SubmitButton>
      </Form>
    </Section>
  );
}
```


## Develop

# Properties

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `id` | `string` | - | The element's unique identifier. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id). |
| `translate` | `"yes" \| "no"` | - | - |
| `className` | `ClassNameOrFunction<RadioGroupRenderProps>` | `'react-aria-RadioGroup'` | The CSS [className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className) for the element. A function may be provided to compute the class based on component state. |
| `style` | `StyleOrFunction<TooltipRenderProps>` | - | The inline [style](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/style) for the element. A function may be provided to compute the style based on component state. |
| `render` | `DOMRenderFunction<"div", TooltipRenderProps>` | - | Overrides the default DOM element with a custom render function. This allows rendering existing components with built-in styles and behaviors such as router links, animation libraries, and pre-styled components. Requirements: - You must render the expected element type (e.g. if `<button>` is expected, you cannot render an `<a>`). - Only a single root DOM element can be rendered (no fragments). - You must pass through props and ref to the underlying DOM element, merging with your own prop as appropriate. |
| `dir` | `string` | - | - |
| `lang` | `string` | - | - |
| `hidden` | `boolean` | - | - |
| `inert` | `boolean` | - | - |
| `validationBehavior` | `"native" \| "aria"` | `'native'` | Whether to use native HTML form validation to prevent form submission when the value is missing or invalid, or mark the field as required or invalid via ARIA. |
| `isDisabled` | `boolean` | - | Whether the input is disabled. |
| `isReadOnly` | `boolean` | - | Whether the input can be selected but not changed by the user. |
| `isRequired` | `boolean` | - | Whether user input is required on the input before form submission. |
| `isInvalid` | `boolean` | - | Whether the input value is invalid. |
| `validate` | `((value: TimeValue) => true \| ValidationError)` | - | A function that returns an error message if a given value is invalid. Validation errors are displayed to the user when the form is submitted if `validationBehavior="native"`. For realtime validation, use the `isInvalid` prop instead. |
| `value` | `TimeValue` | - | The current value (controlled). |
| `defaultValue` | `TimeValue` | - | The default value (uncontrolled). |
| `name` | `string` | - | The name of the input element, used when submitting an HTML form. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#htmlattrdefname). |
| `form` | `string` | - | The `<form>` element to associate the input with. The value of this attribute must be the id of a `<form>` in the same document. See [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#form). |
| `slot` | `string` | - | A slot name for the component. Slots allow the component to receive props from a parent component. An explicit `null` value indicates that the local props completely override all props received from a parent. |
| `orientation` | `Orientation` | `'vertical'` | The axis the Radio Button(s) should align with. |
| `children` | `ReactNode` | - | - |
| `wrapWith` | `ReactElement<unknown, string \| JSXElementConstructor<any>>` | - | - |
| `ref` | `Ref<HTMLSpanElement>` | - | Allows getting a ref to the component instance. Once the component unmounts, React will set `ref.current` to `null` (or call the ref with `null` if you passed a callback ref). @see [React Docs](https://react.dev/learn/referencing-values-with-refs#refs-and-the-dom) |
| `key` | `Key` | - | - |
| `s` | `(number)[]` | - | Column layout for container size s. |
| `m` | `(number)[]` | - | Column layout for container size m. |
| `l` | `(number)[]` | - | Column layout for container size l. |

### Events

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `onClick` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onClickCapture` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onAuxClick` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onAuxClickCapture` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onContextMenu` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onContextMenuCapture` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onDoubleClick` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onDoubleClickCapture` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onMouseDown` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onMouseDownCapture` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onMouseEnter` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onMouseLeave` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onMouseMove` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onMouseMoveCapture` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onMouseOut` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onMouseOutCapture` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onMouseOver` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onMouseOverCapture` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onMouseUp` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onMouseUpCapture` | `MouseEventHandler<HTMLDivElement>` | - | - |
| `onTouchCancel` | `TouchEventHandler<HTMLDivElement>` | - | - |
| `onTouchCancelCapture` | `TouchEventHandler<HTMLDivElement>` | - | - |
| `onTouchEnd` | `TouchEventHandler<HTMLDivElement>` | - | - |
| `onTouchEndCapture` | `TouchEventHandler<HTMLDivElement>` | - | - |
| `onTouchMove` | `TouchEventHandler<HTMLDivElement>` | - | - |
| `onTouchMoveCapture` | `TouchEventHandler<HTMLDivElement>` | - | - |
| `onTouchStart` | `TouchEventHandler<HTMLDivElement>` | - | - |
| `onTouchStartCapture` | `TouchEventHandler<HTMLDivElement>` | - | - |
| `onPointerDown` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onPointerDownCapture` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onPointerMove` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onPointerMoveCapture` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onPointerUp` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onPointerUpCapture` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onPointerCancel` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onPointerCancelCapture` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onPointerEnter` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onPointerLeave` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onPointerOver` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onPointerOverCapture` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onPointerOut` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onPointerOutCapture` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onGotPointerCapture` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onGotPointerCaptureCapture` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onLostPointerCapture` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onLostPointerCaptureCapture` | `PointerEventHandler<HTMLDivElement>` | - | - |
| `onScroll` | `UIEventHandler<HTMLDivElement>` | - | - |
| `onScrollCapture` | `UIEventHandler<HTMLDivElement>` | - | - |
| `onWheel` | `WheelEventHandler<HTMLDivElement>` | - | - |
| `onWheelCapture` | `WheelEventHandler<HTMLDivElement>` | - | - |
| `onAnimationStart` | `AnimationEventHandler<HTMLDivElement>` | - | - |
| `onAnimationStartCapture` | `AnimationEventHandler<HTMLDivElement>` | - | - |
| `onAnimationEnd` | `AnimationEventHandler<HTMLDivElement>` | - | - |
| `onAnimationEndCapture` | `AnimationEventHandler<HTMLDivElement>` | - | - |
| `onAnimationIteration` | `AnimationEventHandler<HTMLDivElement>` | - | - |
| `onAnimationIterationCapture` | `AnimationEventHandler<HTMLDivElement>` | - | - |
| `onTransitionCancel` | `TransitionEventHandler<HTMLDivElement>` | - | - |
| `onTransitionCancelCapture` | `TransitionEventHandler<HTMLDivElement>` | - | - |
| `onTransitionEnd` | `TransitionEventHandler<HTMLDivElement>` | - | - |
| `onTransitionEndCapture` | `TransitionEventHandler<HTMLDivElement>` | - | - |
| `onTransitionRun` | `TransitionEventHandler<HTMLDivElement>` | - | - |
| `onTransitionRunCapture` | `TransitionEventHandler<HTMLDivElement>` | - | - |
| `onTransitionStart` | `TransitionEventHandler<HTMLDivElement>` | - | - |
| `onTransitionStartCapture` | `TransitionEventHandler<HTMLDivElement>` | - | - |
| `onFocus` | `((e: FocusEvent<Element, Element>) => void)` | - | Handler that is called when the element receives focus. |
| `onBlur` | `((e: FocusEvent<Element, Element>) => void)` | - | Handler that is called when the element loses focus. |
| `onFocusChange` | `((isFocused: boolean) => void)` | - | Handler that is called when the element's focus status changes. |
| `onChange` | `((value: TimeValue) => void)` | - | Handler that is called when the value changes. |

### Accessibility

| Property | Type | Default | Description |
| --- | --- | --- | --- |
| `aria-label` | `string` | - | Defines a string value that labels the current element. |
| `aria-labelledby` | `string` | - | Identifies the element (or elements) that labels the current element. |
| `aria-describedby` | `string` | - | Identifies the element (or elements) that describes the object. |
| `aria-details` | `string` | - | Identifies the element (or elements) that provide a detailed, extended description for the object. |
| `aria-errormessage` | `string` | - | Identifies the element that provides an error message for the object. |


## Guidelines

# Grundlagen

Eine RadioGroup enthält mehrere Radios oder RadioButtons als
Optionsmöglichkeiten, von denen jeweils nur eine vom User ausgewählt werden
kann. Die ausgewählte Option wird durch einen ausgefüllten Kreis gekennzeichnet.
Zu Beginn ist häufig eine sinnvolle Option vorausgewählt.

## Best practices

Achte bei der Verwendung einer RadioGroup darauf, dass ...

- ein [Label](/04-components/content/label/overview) verwendet wird, wenn der
  User die RadioGroup sonst nicht selbstständig verstehen kann. Ein anderes
  beschreibendes Element in Nähe der RadioGroup, kann das Label ersetzen, z. B.
  eine [Heading](/04-components/content/heading/overview).
- die Reihenfolge der Optionen gut gewählt ist. In den meisten Fällen ist es
  sinnvoll, die wichtigsten Optionen an den Anfang zu stellen. Wenn die
  RadioGroup in Umfragen verwendet wird, kann es stattdessen sinnvoll sein, die
  Optionen zufällig zu mischen.
- die Optionen für den User leicht zu unterscheiden sind, um Unsicherheit über
  die richtige Wahl zu vermeiden.
- es nicht zu viele Optionen sind. Idealerweise sind es 2-7 Optionen. Bei mehr
  Optionen oder wenn die Optionen nicht sofort sichtbar sein sollen, ist ein
  [Select](/04-components/form-controls/select/overview) die bessere Wahl.
- die Auswahl durch das Anklicken eines Speicher-Buttons bestätigt werden muss.
- es oft ratsam ist, zu Beginn eine Option vorzuselektieren, um Fehlermeldungen
  zu vermeiden.

## Verwendung

Verwende eine RadioGroup, um ...

- dem User eine Einfachauswahl mit ungefähr 2-7 direkt sichtbaren Optionen
  anzubieten.
- als Einfachauswahl-Components in Umfragen verwendet zu werden.
- Einstellungen vorzunehmen, bei denen immer genau eine Option ausgewählt werden
  muss.

## RadioGroup vs. SegmentedControl

Flow bietet verschiedene Auswahl-Components an. RadioGroup und SegmentedControl
ähneln sich sehr. In den Cards unter dem Text sind hilfreiche Anhaltspunkte für
eine Abgrenzung.

  

**ℹ️ Info**

- eine Einfachauswahl von 2 bis ungefähr 7 Optionen anzuzeigen.

    - Optionen mit unterschiedlicher Textlänge darzustellen.

  

**ℹ️ Info**

- eine Einfachauswahl von 2 bis 5 Optionen anzuzeigen.

    - Optionen anzuzeigen, die aus 1 bis 2 Wörtern bestehen.

    - Optionen anzuzeigen, die den darunterliegenden Inhalt verändern.

---

# Anwendung

## Position

RadioGroups werden häufig in Formularen verwendet.

- Radios dürfen nur untereinander und linksbündig dargestellt werden.
- RadioButtons dürfen untereinander und nebeneinander verwendet werden.

# Hierarchie

Da RadioGroups aus mehreren Optionen bestehen, müssen diese in eine logische
Reihenfolge gebracht werden. Folgende Punkte können dabei interessant sein:

- In den meisten Fällen sollte die wichtigste Option an erster Stelle stehen.
  Die wichtigste Option kann z. B. diejenige sein, die am häufigsten vom User
  gewählt wird.
- Eine Option, die ein hohes Risiko für den User darstellt, sollte weiter unten
  in der Liste erscheinen und niemals vorselektiert sein.
- Da eine RadioGroup in der Regel bereits über eine vorselektierte Option
  verfügt, wird die RadioGroup automatisch für den User zur Pflicht. Daher muss
  es immer eine Option geben, die der tatsächlichen Auswahl des Users
  entspricht. Dies bedeutet zum Beispiel, dass in einer Liste von Optionen am
  Ende eine Option mit der Bezeichnung „Andere“ oder „Keine“ angeboten wird.

  

**✅ Do**

Der User kann hier den letzten Punkt auswählen, wenn die anderen Optionen
    nicht zutreffen.

```tsx
import {
  Label,
  Radio,
  RadioGroup,
} from "@mittwald/flow-react-components";

<div style={{ display: "flex", justifyContent: "center" }}>
  <RadioGroup defaultValue="espelkamp">
    <Label>Wohnort</Label>
    <Radio value="espelkamp">Espelkamp</Radio>
    <Radio value="minden">Minden</Radio>
    <Radio value="rahden">Rahden</Radio>
    <Radio value="others">Andere</Radio>
  </RadioGroup>
</div>
```

  

**⛔️ Don't**

Wenn der User woanders wohnt, kann er hier keine richtige Wahl treffen.

```tsx
import {
  Label,
  Radio,
  RadioGroup,
} from "@mittwald/flow-react-components";

<div style={{ display: "flex", justifyContent: "center" }}>
  <RadioGroup defaultValue="espelkamp">
    <Label>Wohnort</Label>
    <Radio value="espelkamp">Espelkamp</Radio>
    <Radio value="minden">Minden</Radio>
    <Radio value="rahden">Rahden</Radio>
    <Radio value="luebbecke">Lübbecke</Radio>
  </RadioGroup>
</div>
```

---

# Inhalt

## Radio

Ein Radio besteht aus zwei Bestandteilen: Einem Kreis, der anzeigt, ob eine
Option ausgewählt ist oder nicht, und einem kurzen beschreibenden Text. Radios
werden immer untereinander angeordnet und werden häufig in Umfragen verwendet.

## RadioButton

Auf Benutzeroberflächen sind häufiger RadioButtons anstelle von Radios zu
finden. RadioButtons haben den Vorteil, dass ...

- mehr Inhalt dargestellt werden kann. RadioButtons können auch eine Headline,
  Fließtext und einen Subtext besitzen. Dabei sollte der Fließtext, jedoch nicht
  länger als 2-3 Zeilen Text sein.
- die Klickfläche durch die Umrandung deutlicher wird und dadurch schneller dem
  User ins Auge springt.
- sie durch das ColumnLayout und die visuelle Umrandung auch nebeneinander
  dargestellt werden können.

---

# Writing guidelines

## Label

Ein [Label](/04-components/content/label/overview) soll dem User helfen
herauszufinden, worum es sich bei der RadioGroup handelt:

- Labels sind platzsparender und unauffälliger. Sie werden verwendet, wenn 1-3
  Wörter ausreichen, um die Optionen der RadioGroup zu beschreiben. Wenn mehr
  Wörter benötigt werden, kann z. B. eine
  [Heading](/04-components/content/heading/overview) in der Nähe der RadioGroup
  platziert werden.
- Achte darauf, dass die Wortwahl verständlich ist und keinen
  Interpretationsspielraum lässt.

  

**✅ Do**

**⛔️ Don't**

```tsx
import { Label } from "@mittwald/flow-react-components";

<div
  style={{
    display: "flex",
    flexDirection: "column",
    alignItems: "center",
  }}
>
  <Label>
    Wähle hier die passende Filtermöglichkeit aus:
  </Label>
  <Label>Wie möchtest du den Vorgang bezahlen?</Label>
</div>
```

## Optionen

Radios und RadioButtons unterscheiden sich in einigen Punkten, die folgenden
Punkte sollten jedoch bei beiden berücksichtigt werden:

- Beginne eine Option immer mit einem Großbuchstaben.
- Versuche die Option so kurz wie möglich zu beschreiben. In einem RadioButton
  können mehrere Sätze in der Mitte stehen, versuche aber nicht mehr als 3 Sätze
  zu schreiben.
- Wenn die Optionen Zahlen enthalten, sollten sich diese nicht überlappen oder
  zwischendrin Zahlen ausgelassen werden.

    Die Auswahl ist eindeutig, da sich kein Alter überschneidet.

```tsx
import { Label } from "@mittwald/flow-react-components";

<div
  style={{
    display: "flex",
    flexDirection: "column",
    alignItems: "center",
  }}
>
  <Label>Filter</Label>
  <Label>Zahlungsmethode</Label>
</div>
```

  

**⛔️ Don't**

Die Optionen überschneiden sich hier, sodass einige User zwei Optionen
    auswählen müssten.

```tsx
import {
  Label,
  Radio,
  RadioGroup,
} from "@mittwald/flow-react-components";

<div style={{ display: "flex", justifyContent: "center" }}>
  <RadioGroup defaultValue="0-10">
    <Label>Alter</Label>
    <Radio value="0-10">0-10 Jahre</Radio>
    <Radio value="10-20">11-20 Jahre</Radio>
    <Radio value="20-30">21-30 Jahre</Radio>
    <Radio value="30-40">31-40 Jahre</Radio>
    <Radio value="40+">40+ Jahre</Radio>
  </RadioGroup>
</div>
```

---

# Accessibility

Achte bei der RadioGroup darauf, dass ...

- wenn kein [Label](/04-components/content/label/overview) verwendet wird ein
  passendes AriaLabel für den Screenreader gesetzt wird, zum Beispiel bei einer
  [Heading](/04-components/content/heading/overview) muss eine
  **aria-labelledby** verwendet werden.
- nie eine Option mit hohem Risiko zum Start vorausgewählt ist, damit diese
  nicht versehentlich ausgewählt wird. Zum Beispiel sollte darauf geachtet
  werden, wenn es um Bezahlung geht.
- die Auswahl durch einen Button bestätigt werden muss.

