# Internal ID software

React components for the tools ID builds for itself: forms, tables, dialogs, navigation and status. Converted from the old system and rebuilt only from the tokens.

Not drawn in Figma. Kasper decided on 20 November 2026 that internal software gets this set now, built only from the tokens. The look is ours until Peter draws it, and every open choice is a question in docs/SPOERGSMAAL-TIL-PETER.md. The public site, campaigns and brand surfaces use only the components drawn in Figma.

Generated from content/software.json and components/software/manifest.json. Live: https://design.id-hub.dk/software

In another app, install @id-identity-as/design-system and import from '@id-identity-as/design-system/software'. The set has its own entry point, so an app for the public does not get it by accident. Import theme.css, fonts.css and components.css from the package as its README says.

## Rules for internal software

- `scope`: Use this set only in internal ID software: tools behind a login that ID's own people use. On id.dk, in campaigns, emails, slides and print, only the components drawn in Figma exist. Why: Figma decides the look of the brand. This set is a working tool, not a brand surface.
- `tokens-only`: Build only from the tokens. The software tokens (color.software.muted, component.field.*) are aliases of Figma values and never values of their own. Do not add one without asking. Why: A value that is not in Figma is a value Peter has not decided. A test fails if a software token holds a value of its own.
- `no-status-colour`: There is no red for errors, no green for success and no yellow for warnings. Say the status in words, and mark what needs attention with weight: a solid Badge, a doubled edge, the heading style. Flare is for the logo only. Why: The old system had a status colour family; Figma has none. Meaning that sits in the word also survives greyscale, a screen reader and a colour blind reader.
- `tints`: A tint is the 200 shade of one colour family with Ink text. Keep to the lead and the accent family of the page, and to pairs that go together. Why: Peter's rule for 200 shades, and the colour pair rule. A tint decorates or groups; it does not carry a meaning on its own.
- `flat`: Surfaces are flat: a hairline in border/default, the base surface, radius/sm. No shadow, no gradient, no second radius. Why: Figma has no shadows, and radius/md and radius/lg have no decided use yet.
- `native-first`: Use the native element: input, select, textarea, checkbox, radio, dialog, table, a link. A form posts without script. Why: The browser brings validation, autofill, keyboards, the focus trap and translations for free, and a native control never drops its value on the way to the server.
- `forms`: Every field has a visible label and an autocomplete token. Optional fields are marked; required ones are not. An error says what to do, replaces the helper, and is repeated in an ErrorSummary first in the form. Why: Carried over from the old form rules: a field the browser cannot fill is typed wrong, and a reader should not hunt for what went wrong.
- `links-and-actions`: Navigation is a link, a change is a Button. One solid Button per view. Pages, filters and tabs that should be shareable live in the address. Why: Back, bookmarks and shared links only work when a place is a link.
- `messages`: The outcome of an action is a FlashMessage in the flow of the page, until the next navigation. No toasts and no timers. A note that is part of the content is a Callout. A decision that cannot wait is a Dialog. Why: A confirmation that disappears before it is read was never given.
- `waiting`: A wait is shown where it happens: a Skeleton with the shape of the content, or a PendingNote for a region. Never disable a submit button to show a wait; set aria-busy. Why: A disabled submit is left out of the form data, and a placeholder of the wrong shape only postpones the jump.
- `data`: Numbers come in formatted, the Danish way (1.234,56, kr. 139,00, 14. august 2026), and are never computed in a component. Mark example data as example data. Never invent a figure, a customer or a product fact. Why: A component cannot know the currency, the rounding or the source.
- `charts`: StatCard and BarList are layout: text and one colour of bar. For axes, time series and several series, ask first. Charts are not in the system yet. Why: Figma has no chart colours, and the eight families are not a data palette.
- `text-as-props`: Every text a component shows or reads aloud is a prop. The built-in defaults are Danish and can be replaced. Why: Fixed strings in a component were a mistake in the old system.
- `themes`: A dark ground is data-theme="dark" on a container. The components turn themselves; do not restyle them. Secondary text is the muted tone, never an opacity or a grey chosen by hand. Why: The muted tone is measured in both themes at every build.
- `motion`: Nothing moves except the two waiting marks, and they stand still for a reader who asks for less motion. No transition on a dialog, a drawer or a tab. Why: Motion is not decided in Figma yet.
- `layout`: Lay a page out on the nine-column grid with Grid, and set rhythm with Stack: inline steps inside a group, section steps between groups. The old twelve-column grid and its spacing scale are gone. Why: Peter's rules for grid and spacing.
- `server-first`: Everything renders on the server except Dialog, Drawer, Tabs, QuantityStepper, CopyButton and PrintButton, which are Client Components. Pass the link of the framework with the as prop. Why: A page that needs no state should need no script.
- `missing`: If what you need is not in this set, say so and ask. Do not build a new component from loose values, and do not bring one in from another library. Why: The same rule as for the Figma components.

## The software components

These 33 components exist for internal ID software, beside the 5 drawn in Figma (Button, UtilityButton, VariationPicker, ProductCard, Icon). Nothing else does.

| Group | Components |
| --- | --- |
| Layout | Stack, Grid |
| Text | Heading, Text, Link |
| Surfaces | Card, CardHeader, Actions |
| Status and waiting | Badge, Skeleton, PendingNote, EmptyState, Callout, FlashMessage |
| Data | StatCard, Table, BarList |
| Navigation | Pagination, Breadcrumb, Navigation |
| Forms | FormField, Input, Textarea, Select, Checkbox, RadioGroup, ErrorSummary, QuantityStepper |
| Overlays | Dialog, Drawer, Tabs |
| Tools | CopyButton, PrintButton |

## Tokens for internal software

Aliases of values from Figma, never values of their own.

| Token | Light | Dark | Utility | Use |
| --- | --- | --- | --- | --- |
| component.field.padding-top | component/button/padding-top | component/button/padding-top | pt-field-padding-top | A form field is as tall as the CTA button beside it: the same padding above the text. |
| component.field.padding-bottom | component/button/padding-bottom | component/button/padding-bottom | pb-field-padding-bottom | A form field is as tall as the CTA button beside it: the same padding below the text. |
| component.field.padding-x | component/button/padding-x | component/button/padding-x | px-field-padding-x | A form field has the CTA button's padding at the sides. |
| color.software.muted | neutral/600 | neutral/300 | text-software-muted | Secondary text in internal software: helper text, captions, timestamps. Light: Charcoal. Dark: Ash. Ours until Peter draws one; not for the public site. |

## Stack

Rhythm as a decision: one gap between the children, taken from the spacing steps.

Group: Layout. Code: `components/software/layout.tsx`. From the old system: Stack in @id-identity-as/ui/layout. Live: https://design.id-hub.dk/software/stack

```tsx
import { Stack } from '@/components/software/layout';

<Stack gap="section-1">
  <Heading level={1}>Ordrer</Heading>
  <Stack gap="inline-3">
    <Text>24 åbne ordrer.</Text>
    <Text tone="muted">Opdateret i dag.</Text>
  </Stack>
</Stack>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| gap | `Space` | `'inline-4'` | The space between the children: 'none', 'seam', 'inline-1' to 'inline-5' or 'section-1' to 'section-4'. |
| direction | `'column' \| 'row'` | `'column'` | Column stacks downwards. Row sets the children side by side and wraps. |
| align | `'start' \| 'center' \| 'end' \| 'stretch'` | `'stretch'` | How the children sit across the direction. |
| as | `ElementType` | `'div'` | The element to render, such as "ul" or "section". |

Do:
- Use an inline step inside a group and a section step between groups.
- Nest stacks: a section stack of groups, each an inline stack.

Do not:
- Do not put a margin on a child to adjust the rhythm. Change the gap.
- Do not look for a step between 20 and 40 px. There is none.

Accessibility:
- It adds no role. Pass as="ul" or as="section" when the content is a list or a region.

## Grid

The nine-column grid, with cells that span thirds or the split four and five.

Group: Layout. Code: `components/software/layout.tsx`. From the old system: Grid in @id-identity-as/ui/layout (twelve columns, now nine). Live: https://design.id-hub.dk/software/grid

```tsx
import { Grid, GridItem } from '@/components/software/layout';

<Grid gap="inline-4">
  <GridItem span={6}>...</GridItem>
  <GridItem span={3}>...</GridItem>
</Grid>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| gap | `Space` | `'none'` | On Grid: the space between the cells. The web grid has no gutter, so the default is none. |
| span | `3 \| 4 \| 5 \| 6 \| 9` | `9` | On GridItem: how many of the nine columns the cell takes from a tablet up. On a phone every cell is the full width. |
| as | `ElementType` | `'div'` | On both: the element to render. |

Do:
- Span counts that divide nine: 3, 6 and 9, or the split 4 and 5.
- Use the seam as the gap between tiles of one block.

Do not:
- Do not span 2, 7 or 8 columns. The grid has no such cell.
- Do not bring the old twelve-column grid along. It is nine now.

Accessibility:
- The order in the code is the reading order. Do not reorder cells with CSS.

## Heading

A heading where the level in the outline and the text style are two decisions.

Group: Text. Code: `components/software/typography.tsx`. From the old system: Heading and Eyebrow in @id-identity-as/ui/layout. Live: https://design.id-hub.dk/software/heading

```tsx
import { Heading } from '@/components/software/typography';

<Heading level={1}>Ordrer</Heading>
<Heading level={2} size="heading-md">Afventer godkendelse</Heading>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| level (required) | `1 \| 2 \| 3 \| 4 \| 5 \| 6` |  | The level in the outline of the page: 1 for the page title, 2 for a section. |
| size | `'display-xl' \| 'display-lg' \| 'display-md' \| 'display-sm' \| 'heading-md' \| 'heading-sm'` |  | The Figma text style. Without it: display-md for level 1, display-sm for 2, heading-md for 3, heading-sm below. |
| id | `string` |  | For aria-labelledby on the region the heading names. |

Do:
- Choose the level from the outline, then the size from what the page needs.
- One level 1 per page.
- In a dense tool, set the page title in display-sm and the sections in heading-md.

Do not:
- Do not pick h3 because h2 looked too big. Keep the level and change the size.
- Do not set a heading in capitals or in a colour. The old eyebrow in mono capitals is gone.

Accessibility:
- The level is what a screen reader navigates by. Do not skip one.

## Text

Body text in one of the body styles, default or muted.

Group: Text. Code: `components/software/typography.tsx`. From the old system: Text in @id-identity-as/ui/layout. Live: https://design.id-hub.dk/software/text

```tsx
import { Text } from '@/components/software/typography';

<Text measure>Ordrer fra dine kolleger vises her, når de er godkendt.</Text>
<Text size="sm" tone="muted">Opdateret 14. august 2026</Text>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| size | `'sm' \| 'md' \| 'lg'` | `'md'` | Body/sm (13 px), Body/md (16 px, the default on screen) or Body/lg (24 px). |
| tone | `'default' \| 'muted'` | `'default'` | Muted is for secondary text: a helper line, a caption, a timestamp. |
| measure | `boolean` | `false` | Caps the line length so a paragraph stays readable. |
| as | `ElementType` | `'p'` | The element to render: "p", "span" or "div". |

Do:
- Set measure on running text of more than a line or two.
- Use muted for what supports the main line, never for the main line itself.

Do not:
- Do not use Body/xs (10 px) for text that must be read. It is not offered here.
- Do not grey text with opacity or with Stone by hand. Muted holds contrast in light and dark.

Accessibility:
- Muted is Charcoal on light and Ash on dark: both hold 4.5:1 on the base surface. The build measures it.

## Link

A link that looks like one: underlined inside a sentence, plain when it stands alone.

Group: Text. Code: `components/software/typography.tsx`. From the old system: Link in @id-identity-as/ui/layout. Live: https://design.id-hub.dk/software/link

```tsx
import { Link } from '@/components/software/typography';

<Text>Se <Link href="/ordrer/41028">ordre 41028</Link> for detaljer.</Text>
<Link variant="block" as={NextLink} href="/ordrer">Alle ordrer</Link>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| variant | `'inline' \| 'block'` | `'inline'` | Inline is a link in a sentence, underlined. Block is a link on its own, such as a row in a list, underlined on hover. |
| as | `ElementType` | `'a'` | The element to render, such as the link of the framework. |
| ...anchor | `AnchorHTMLAttributes` |  | Everything a native anchor takes: href, target, rel. |

Do:
- Use it for navigation. An action that changes something is a Button.
- Write the link text so it says where it leads: "ordre 41028", not "klik her".

Do not:
- Do not colour a link. It is the text colour, and never Flare.
- Do not remove the underline from a link in a sentence.

Accessibility:
- Links in running text are underlined: colour alone does not tell a link from the words around it.
- Focus shows the ring in the text colour.

## Card

A surface with a hairline border that knows nothing about what is in it.

Group: Surfaces. Code: `components/software/card.tsx`. From the old system: Card in @id-identity-as/ui. Live: https://design.id-hub.dk/software/card

```tsx
import { Card, CardHeader } from '@/components/software/card';

<Card>
  <CardHeader eyebrow="Ordre 41028" title="Afventer godkendelse" hint="Oprettet 28. august af Mette N." />
  <Text>2 linjer</Text>
</Card>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| as | `ElementType` | `'section'` | The element to render. A card names a region of the page. |
| padding | `'md' \| 'lg'` | `'md'` | Md is 20 px of padding, lg is 40 px. |

Do:
- Let the border do the work. A page of bordered panels reads as order.
- Give a card a CardHeader when it is a region of its own.

Do not:
- Do not add a shadow. There is none in the system.
- Do not nest a card in a card. Use a hairline or a Stack inside.
- Do not put a packshot in a card: packshots sit on Snow, in a ProductCard.

Accessibility:
- As a section it should be named: give it a CardHeader, or an aria-label through as and your own element.

## CardHeader

The top of a card: what it is, and at most one thing to do with it.

Group: Surfaces. Code: `components/software/card.tsx`. From the old system: CardHeader in @id-identity-as/ui. Live: https://design.id-hub.dk/software/card-header

```tsx
import { Card, CardHeader } from '@/components/software/card';

<CardHeader title="Brugere" hint="12 aktive" action={<Link variant="block" href="/brugere">Se alle</Link>} />
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| title (required) | `string` |  | The name of what the card holds. |
| level | `2 \| 3 \| 4` | `3` | The heading level of the title in the outline of the page. |
| eyebrow | `string` |  | A short line above the title, such as "Ordre 41028". |
| hint | `string` |  | A short line under the title, such as who and when. |
| action | `ReactNode` |  | One control at the end of the header, such as a link or a button. |

Do:
- Keep the title to a few words. Heading names things.
- Set level so the title fits the outline around the card.

Do not:
- Do not put two actions in the header. The second belongs in the card.
- Do not write the eyebrow in capitals.

Accessibility:
- The title is a real heading, so the card lands in the outline of the page.

## Badge

A status chip. The word carries the meaning; the colour never does alone.

Group: Status and waiting. Code: `components/software/badge.tsx`. From the old system: Badge in @id-identity-as/ui (ten coloured variants, now three). Live: https://design.id-hub.dk/software/badge

```tsx
import { Badge } from '@/components/software/badge';

<Badge>Kladde</Badge>
<Badge variant="tint">I gang</Badge>
<Badge variant="solid">Afventer godkendelse</Badge>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| variant | `'outline' \| 'solid' \| 'tint'` | `'outline'` | Outline is the quiet default. Solid is for the one status that needs to be seen. Tint is a light ground with Ink text. |
| family | `ColourFamily` |  | The colour family of a tint: 'red', 'brown', 'tan', 'khaki', 'green', 'teal', 'blue' or 'purple'. Without it the tint is Mist. |

Do:
- Write the status as a word: "Godkendt", "Afvist".
- Keep a family tint to the lead and the accent of the page, by the colour pair rule.
- Use solid for one kind of status per view, the one that asks for action.

Do not:
- Do not use Flare, and do not use red for errors or green for approved. The system has no status colours.
- Do not let two tints from families that do not go together sit side by side.
- Do not put a badge on a product tile here. Commerce flags wait for Figma.

Accessibility:
- The meaning is in the text, so it survives greyscale and a screen reader.
- A tint is a 200 shade with Ink text: at least 11.9:1.

## Actions

A row for the actions that share a moment, such as save and cancel.

Group: Surfaces. Code: `components/software/actions.tsx`. From the old system: Actions in @id-identity-as/ui. Live: https://design.id-hub.dk/software/actions

```tsx
import { Actions } from '@/components/software/actions';

<Actions>
  <Button type="submit">Gem ordren</Button>
  <Button variant="outline">Annullér</Button>
</Actions>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| align | `'start' \| 'end'` | `'start'` | End sets the actions at the end of the row, as in the foot of a dialog. |

Do:
- One solid Button and the outline beside it.
- Put the primary action first.

Do not:
- Do not stretch the buttons to the full width. Each keeps the width of its label.
- Do not put two solid buttons in one row.

Accessibility:
- The order in the code is the tab order: primary first.

## Skeleton

A placeholder with the shape of the content that has not arrived yet.

Group: Status and waiting. Code: `components/software/waiting.tsx`. From the old system: Skeleton and SkeletonText in @id-identity-as/ui. Live: https://design.id-hub.dk/software/skeleton

```tsx
import { Skeleton, SkeletonText } from '@/components/software/waiting';

<div aria-busy="true">
  <Skeleton className="h-section-1 w-full" />
  <SkeletonText lines={3} />
</div>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| className | `string` |  | On Skeleton: the size of the block, with token utilities such as "h-section-1 w-full". |
| lines | `number` | `3` | On SkeletonText: how many lines the text will take. The last runs short. |

Do:
- Build the shape of the real content out of several skeletons.
- Set aria-busy="true" on the region that will receive the content.

Do not:
- Do not drop in one grey box for a whole page. A placeholder of the wrong size only postpones the jump.
- Do not show a skeleton for a wait under a second.

Accessibility:
- Hidden from screen readers; the region around it carries aria-busy.
- The pulse stops for a reader who asks for less motion.

## PendingNote

A sentence that says a region is working, announced once.

Group: Status and waiting. Code: `components/software/waiting.tsx`. From the old system: PendingNote in @id-identity-as/ui. Live: https://design.id-hub.dk/software/pending-note

```tsx
import { PendingNote } from '@/components/software/waiting';

<PendingNote>Beregner totalen igen</PendingNote>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| children (required) | `ReactNode` |  | What is happening, as a sentence. |

Do:
- Use it when the wait belongs to a region: a total, a count, a list.
- Say what is happening, not "Vent venligst".

Do not:
- Do not use it as a full page loader.
- Do not disable a submit button while waiting: a disabled submit is left out of the form data. Set aria-busy on it instead.

Accessibility:
- role="status": the sentence is read once when it appears and does not take focus.
- The icon stands still for a reader who asks for less motion.

## EmptyState

The empty case of a list or a search: what is missing, why, and one way out.

Group: Status and waiting. Code: `components/software/empty-state.tsx`. From the old system: EmptyState in @id-identity-as/ui/data. Live: https://design.id-hub.dk/software/empty-state

```tsx
import { EmptyState } from '@/components/software/empty-state';

<EmptyState
  title="Ingen ordrer endnu"
  text="Ordrer fra dine kolleger vises her, når de er godkendt."
  action={<a className={buttonClasses({ variant: 'outline' })} href="/katalog">Gå til kataloget</a>}
/>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| title (required) | `string` |  | What is missing, as a heading. |
| level | `2 \| 3 \| 4` | `3` | The heading level of the title. |
| text | `string` |  | Why it is empty, and what makes it fill. |
| action | `ReactNode` |  | The one way out, such as a link styled with buttonClasses. |

Do:
- Tell an empty list from an empty search: "Ingen ordrer endnu" is not "Ingen ordrer i perioden".
- Give one way out.

Do not:
- Do not leave a table with only its header. Show the empty state instead.
- Do not decorate it with an illustration or an icon the set does not have.

Accessibility:
- The title is a heading, so it lands in the outline of the page.

## StatCard

One number with its name, its change and its source.

Group: Data. Code: `components/software/stat-card.tsx`. From the old system: StatCard in @id-identity-as/ui/data. Live: https://design.id-hub.dk/software/stat-card

```tsx
import { StatCard } from '@/components/software/stat-card';

<StatCard label="Åbne ordrer" value="12" delta="+3" deltaDirection="up" deltaBasis="i forhold til sidste uge" source="Eksempeldata" />
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| label (required) | `string` |  | What is measured. |
| value (required) | `string` |  | The number, already formatted: "1.240" or "68 %". Never computed in the card. |
| delta | `string` |  | The change, already formatted. |
| deltaDirection | `'up' \| 'down'` |  | Draws an arrow beside the change. The direction is not a verdict. |
| deltaBasis | `string` |  | What the change is measured against. |
| source | `string` |  | Where the number comes from and what period it covers. |

Do:
- Format the number the Danish way before it comes in: 1.234,56.
- Say in words whether a change is good. Returns going down is an arrow down that is good.
- Name the source, and mark example data as example data.

Do not:
- Do not colour the change green or red.
- Do not animate the number.
- Do not invent a figure to fill a tile.

Accessibility:
- A section named by its label.
- The arrow is decorative; the change is text.

## Callout

A note that belongs to the content around it: a condition, a reminder, a source.

Group: Status and waiting. Code: `components/software/message.tsx`. From the old system: Callout in @id-identity-as/ui/data (five coloured variants, now two). Live: https://design.id-hub.dk/software/callout

```tsx
import { Callout } from '@/components/software/message';

<Callout title="Kræver godkendelse">To ordrelinjer overstiger budgettet for afdelingen.</Callout>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| title | `string` |  | A short heading for the note. |
| variant | `'outline' \| 'tint'` | `'outline'` | Outline is a hairline box. Tint is a light ground with Ink text. |
| family | `ColourFamily` |  | The colour family of a tint. Without it the tint is Mist. |

Do:
- Use it for something the reader should know before going on.
- Say what kind of note it is in the title: "Kræver godkendelse".

Do not:
- Do not use it for the outcome of an action. That is FlashMessage.
- Do not rely on a tint to say warning or error. Say it in the title.
- Do not stack several callouts. If everything is a note, nothing is.

Accessibility:
- role="note": part of the page from the start, not announced on its own.

## FlashMessage

What the page says about the thing you just did. In the flow, not a toast.

Group: Status and waiting. Code: `components/software/message.tsx`. From the old system: FlashMessage in @id-identity-as/ui/commerce. Live: https://design.id-hub.dk/software/flash-message

```tsx
import { FlashMessage } from '@/components/software/message';

<FlashMessage title="Ordren er gemt">Antal ændret fra 24 til 48.</FlashMessage>
<FlashMessage tone="alert" title="Ordren blev ikke gemt">Prøv igen, eller kontakt support.</FlashMessage>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| title (required) | `string` |  | What happened, as a short sentence. |
| tone | `'status' \| 'alert'` | `'status'` | Status is news that can wait its turn. Alert interrupts, for when something failed. |
| id | `string` | `'besked'` | A stable id, so the page that follows an action can send focus to the message. |
| action | `ReactNode` |  | One way on from here, such as a link. |
| children | `ReactNode` |  | The detail under the title. |

Do:
- Place it at the top of the content, and leave it until the next navigation.
- Send focus to it after a redirect, so the outcome is the first thing read.
- Use alert only when something failed and the reader must act.

Do not:
- Do not make it disappear on a timer. A confirmation gone before it is read was never given.
- Do not float it over the page as a toast.
- Do not colour an alert red. It is marked by a doubled edge in the text colour.

Accessibility:
- role="status" is read when the reader is free; role="alert" interrupts.
- It can take focus from script (tabindex -1) without joining the tab order.

## Table

A data table with hairlines between the rows, numbers right aligned, and its own sideways scroll.

Group: Data. Code: `components/software/table.tsx`. From the old system: Table in @id-identity-as/ui/commerce. Live: https://design.id-hub.dk/software/table

```tsx
import { Table } from '@/components/software/table';

<Table
  caption="Ordrelinjer"
  rowHeader="sku"
  columns={[
    { key: 'sku', header: 'Varenr.' },
    { key: 'name', header: 'Produkt' },
    { key: 'quantity', header: 'Antal', align: 'end' },
  ]}
  rows={lines}
/>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| caption (required) | `string` |  | What the table holds. Shown above it and read aloud as its name. |
| captionHidden | `boolean` | `false` | Hides the caption from the eye when a heading right above already says it. |
| columns (required) | `TableColumn[]` |  | { key, header, align? }. align: 'end' is for numbers. |
| rows (required) | `TableRow[]` |  | One object per row, with a cell for each column key. Numbers come in formatted. |
| rowHeader | `string` |  | The key of the column that names each row. Its cells become row headers. |

Do:
- Right align numbers with align: 'end'. They are set in tabular figures.
- Name the row with rowHeader, such as the order number.
- Paginate a long list with Pagination.

Do not:
- Do not draw a full grid or stripe the rows. Hairlines only.
- Do not use a table for layout.
- Do not leave an empty table. Show an EmptyState.

Accessibility:
- A real table with a caption, column headers and, with rowHeader, row headers.
- The frame scrolls sideways and can take focus, so a keyboard reaches the columns off screen.

## BarList

A ranked list with a bar behind each number. Layout, not a chart.

Group: Data. Code: `components/software/bar-list.tsx`. From the old system: BarList in @id-identity-as/ui/data. Live: https://design.id-hub.dk/software/bar-list

```tsx
import { BarList } from '@/components/software/bar-list';

<BarList
  title="Mest bestilte"
  note="Eksempeldata, antal stk."
  rows={[
    { label: 'Række A', value: 1425, text: '1.425' },
    { label: 'Række B', value: 980, text: '980' },
  ]}
/>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| title (required) | `string` |  | What is compared. |
| note | `string` |  | The period and the unit. |
| rows (required) | `BarListRow[]` |  | { label, value, text }. value draws the bar; text is the number as shown, already formatted. |

Do:
- Keep the order of the rows fixed when the data updates.
- Write the unit in the note.

Do not:
- Do not give the bars different colours. One colour, the text colour.
- Do not animate the bars.
- Do not use it where an axis or a time line is needed. Charts are not in the system yet: ask first.

Accessibility:
- Every value is text beside its bar; the bar itself is hidden from screen readers.

## Pagination

Moving through a long list, as a list of links.

Group: Navigation. Code: `components/software/pagination.tsx`. From the old system: Pagination in @id-identity-as/ui/commerce. Live: https://design.id-hub.dk/software/pagination

```tsx
import { Pagination } from '@/components/software/pagination';

<Pagination page={3} pageCount={12} href={(page) => `/ordrer?side=${page}`} />
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| page (required) | `number` |  | The page shown now, from 1. |
| pageCount (required) | `number` |  | How many pages there are. With one page nothing is rendered. |
| href (required) | `(page: number) => string` |  | The address of a page. Every page is a real link. |
| labels | `Partial<PaginationLabels>` |  | { nav, previous, next, page }. Danish by default. Pass translations here. |
| as | `ElementType` | `'a'` | The element to render a link with, such as the link of the framework. |

Do:
- Keep the page in the address, so back, bookmarks and shared links work.
- Say above the list what is shown: "Viser 49 til 72 af 270".

Do not:
- Do not build it from buttons with state. A page is a place, so it is a link.
- Do not replace it with an endless "Vis flere". Everything past the first page is then out of reach.

Accessibility:
- A named navigation. The current page has aria-current and is not a link.
- At the first and the last page the edge is plain text, not a disabled button.

## Breadcrumb

The trail from the front of the app to this page.

Group: Navigation. Code: `components/software/navigation.tsx`. From the old system: Breadcrumb in @id-identity-as/ui/commerce. Live: https://design.id-hub.dk/software/breadcrumb

```tsx
import { Breadcrumb } from '@/components/software/navigation';

<Breadcrumb items={[{ label: 'Ordrer', href: '/ordrer' }, { label: 'Ordre 41028' }]} />
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| items (required) | `BreadcrumbItem[]` |  | { label, href? } from the start to here. The last item is the current page and has no href. |
| label | `string` | `'Brødkrumme'` | The name of the navigation, read aloud. |
| as | `ElementType` | `'a'` | The element to render a link with. |

Do:
- End the trail on the current page, as text.
- Use it from the third level down. Two levels need no trail.

Do not:
- Do not make the current page a link. A link to where you are is a dead end.
- Do not use a chevron as the separator. At body size it reads as a control; the separator is a slash.

Accessibility:
- A named navigation with an ordered list; the current page has aria-current="page".
- The separators are hidden from screen readers.

## Navigation

The way around an app: a named list of links with the current page marked.

Group: Navigation. Code: `components/software/navigation.tsx`. From the old system: Navigation in @id-identity-as/ui/chrome (the list of links, without the public site chrome). Live: https://design.id-hub.dk/software/navigation

```tsx
import { Navigation } from '@/components/software/navigation';

<Navigation
  label="Hovedmenu"
  items={[
    { href: '/ordrer', label: 'Ordrer', current: true },
    { href: '/brugere', label: 'Brugere' },
  ]}
/>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| label (required) | `string` |  | The name of the navigation, read aloud. |
| items (required) | `NavigationItem[]` |  | { href, label, current? }. current marks the page the reader is on. |
| orientation | `'vertical' \| 'horizontal'` | `'vertical'` | Vertical is a list down the side of an app. Horizontal is a row that wraps. |
| as | `ElementType` | `'a'` | The element to render a link with. |

Do:
- Name every navigation: "Hovedmenu", "Indstillinger".
- Set it in the first two or three columns of the grid, with the page in the rest.
- On a phone, put a vertical navigation in a Drawer.

Do not:
- Do not mark the current page with a colour. It is underlined and set in the heading weight.
- Do not use it for the public site. Its navigation and footer wait for Figma.

Accessibility:
- The current page has aria-current="page".
- Two navigations on one page have two different names.

## FormField

A label, a control and the one message under it, wired together.

Group: Forms. Code: `components/software/form.tsx`. From the old system: FormField in @id-identity-as/ui/form. Live: https://design.id-hub.dk/software/form-field

```tsx
import { FormField } from '@/components/software/form';

<FormField id="period" label="Periode" helper="Vælg hele uger.">
  <input id="period" name="period" type="week" />
</FormField>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| id (required) | `string` |  | The id of the control inside. Give the control the same id. |
| label (required) | `string` |  | The visible label. |
| helper | `string` |  | Guidance shown under the field when there is no error. |
| error | `string` |  | What to do about a problem. Replaces the helper. |
| required | `boolean` |  | Required fields carry no mark. The optional ones are marked. |
| optionalLabel | `string` | `'(valgfrit)'` | The mark on an optional field. |

Do:
- Use it for a control this set does not cover, such as a date or a file.
- Point the control at the message yourself: aria-describedby="{id}-helper" or "{id}-error".

Do not:
- Do not use it around Input, Textarea or Select. They bring their own.
- Do not mark the required fields with an asterisk. The optional ones carry the mark.

Accessibility:
- The label is tied to the control by id.
- The error has the id "{id}-error" and the helper "{id}-helper".

## Input

A single line of text, with its label, its helper and its error.

Group: Forms. Code: `components/software/form.tsx`. From the old system: Input in @id-identity-as/ui/form. Live: https://design.id-hub.dk/software/input

```tsx
import { Input } from '@/components/software/form';

<Input label="Firma" name="company" autoComplete="organization" required />
<Input label="CVR-nummer" name="cvr" autoComplete="off" inputMode="numeric" helper="Otte cifre uden mellemrum." />
<Input label="E-mail" name="email" type="email" autoComplete="email" required error="Skriv en e-mailadresse, fx mette@firma.dk" />
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| label (required) | `string` |  | The visible label. Never a placeholder. |
| name (required) | `string` |  | The form field name. |
| autoComplete (required) | `AutoCompleteToken` |  | An HTML autocomplete token such as "email" or "organization", or "off" as the explicit refusal. |
| helper | `string` |  | Guidance shown under the field when there is no error. |
| error | `string` |  | What to do about a problem. Its presence puts the field in its error state. |
| required | `boolean` |  | Required fields carry no mark. The optional ones are marked. |
| optionalLabel | `string` | `'(valgfrit)'` | The mark on an optional field. Pass a translation here. |
| ...input | `InputHTMLAttributes` |  | Everything a native input takes: type, inputMode, defaultValue, onChange, disabled. |

Do:
- Choose the autocomplete token. "off" is a real answer for a number that belongs to one order.
- Write the error as what to do: "Skriv alle 8 cifre", not "Ugyldigt CVR".
- Set type and inputMode, so a phone shows the right keyboard.

Do not:
- Do not use the placeholder as the label.
- Do not colour an error red. The edge doubles in the text colour and the message is set in the heading weight.
- Do not post a form to DynamicWeb from a React field. DynamicWeb takes native inputs in its own templates.

Accessibility:
- A native input with a real label.
- In error it has aria-invalid, and aria-describedby points at the error; otherwise at the helper. Never both.
- The edge of the field is Stone: at least 3:1 against the surface in light and dark.

## Textarea

Several lines of text.

Group: Forms. Code: `components/software/form.tsx`. From the old system: Textarea in @id-identity-as/ui/form. Live: https://design.id-hub.dk/software/textarea

```tsx
import { Textarea } from '@/components/software/form';

<Textarea label="Besked til lageret" name="note" autoComplete="off" helper="Følger ordren, ikke fakturaen." />
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| label (required) | `string` |  | The visible label. Never a placeholder. |
| name (required) | `string` |  | The form field name. |
| autoComplete (required) | `AutoCompleteToken` |  | An HTML autocomplete token such as "email" or "organization", or "off" as the explicit refusal. |
| helper | `string` |  | Guidance shown under the field when there is no error. |
| error | `string` |  | What to do about a problem. Its presence puts the field in its error state. |
| required | `boolean` |  | Required fields carry no mark. The optional ones are marked. |
| optionalLabel | `string` | `'(valgfrit)'` | The mark on an optional field. Pass a translation here. |
| rows | `number` | `4` | How many lines it shows before it scrolls. |
| ...textarea | `TextareaHTMLAttributes` |  | Everything a native textarea takes. |

Do:
- Say in the helper who reads the text.
- Set rows to the amount of text you expect.

Do not:
- Do not use it for a single line. That is Input.

Accessibility:
- A native textarea with a real label, wired to its helper or its error like Input.

## Select

One choice from a list, as the native select.

Group: Forms. Code: `components/software/form.tsx`. From the old system: Select in @id-identity-as/ui/form. Live: https://design.id-hub.dk/software/select

```tsx
import { Select } from '@/components/software/form';

<Select
  label="Afdeling"
  name="department"
  autoComplete="off"
  required
  placeholder="Vælg en afdeling"
  options={[{ value: 'salg', label: 'Salg' }, { value: 'lager', label: 'Lager' }]}
/>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| label (required) | `string` |  | The visible label. Never a placeholder. |
| name (required) | `string` |  | The form field name. |
| autoComplete (required) | `AutoCompleteToken` |  | An HTML autocomplete token such as "email" or "organization", or "off" as the explicit refusal. |
| helper | `string` |  | Guidance shown under the field when there is no error. |
| error | `string` |  | What to do about a problem. Its presence puts the field in its error state. |
| required | `boolean` |  | Required fields carry no mark. The optional ones are marked. |
| optionalLabel | `string` | `'(valgfrit)'` | The mark on an optional field. Pass a translation here. |
| options (required) | `SelectOption[]` |  | { value, label, disabled? }. |
| placeholder | `string` |  | The empty first option, such as "Vælg en afdeling". |
| ...select | `SelectHTMLAttributes` |  | Everything a native select takes. |

Do:
- Give it a placeholder, so nobody has chosen without choosing.
- Use it from about six options. For fewer, a RadioGroup shows them all.

Do not:
- Do not build a custom list box. The native select works with a keyboard, a phone and a form post.
- Do not use it for navigation.

Accessibility:
- A native select with a real label.
- The chevron is decorative and hidden from screen readers.

## Checkbox

One checkbox: a consent, a preference, a setting.

Group: Forms. Code: `components/software/form.tsx`. From the old system: Checkbox in @id-identity-as/ui/form. Live: https://design.id-hub.dk/software/checkbox

```tsx
import { Checkbox } from '@/components/software/form';

<Checkbox name="terms" required label="Jeg accepterer, at priserne er ekskl. moms" />
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| name (required) | `string` |  | The form field name. |
| label (required) | `ReactNode` |  | Written as a sentence the reader agrees to, not as a field name. |
| helper | `string` |  | Guidance under the checkbox. |
| error | `string` |  | What to do about a problem. |
| required | `boolean` |  | The box must be ticked before the form posts. |
| ...input | `InputHTMLAttributes` |  | Everything a native checkbox takes: defaultChecked, onChange, value. |

Do:
- Write the label as a full sentence.
- For several options under one question, use a fieldset with a legend around the checkboxes.

Do not:
- Do not tick a consent in advance.
- Do not use a checkbox for a choice between two named things. That is a RadioGroup.

Accessibility:
- A native checkbox; the label is part of the click target.
- It is ticked in the text colour, never in Flare.

## RadioGroup

One question with a few answers, all shown.

Group: Forms. Code: `components/software/form.tsx`. From the old system: RadioGroup in @id-identity-as/ui/form. Live: https://design.id-hub.dk/software/radio-group

```tsx
import { RadioGroup } from '@/components/software/form';

<RadioGroup
  label="Levering"
  name="delivery"
  required
  defaultValue="standard"
  options={[{ value: 'standard', label: 'Standard, 2 til 4 dage' }, { value: 'express', label: 'Ekspres, næste hverdag' }]}
/>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| label (required) | `string` |  | The question. It is the legend of the group. |
| name (required) | `string` |  | The form field name. One group is one question. |
| options (required) | `SelectOption[]` |  | { value, label, disabled? }. |
| value | `string` |  | The chosen value. With onChange the group is controlled. |
| defaultValue | `string` |  | The value chosen from the start, uncontrolled. |
| onChange | `(value: string) => void` |  | Called with the new value. |
| helper | `string` |  | Guidance under the group. |
| error | `string` |  | What to do about a problem. |
| required | `boolean` |  | Required groups carry no mark. The optional ones are marked. |
| optionalLabel | `string` | `'(valgfrit)'` | The mark on an optional group. |

Do:
- Use it for up to about five answers. More than that is a Select.
- Choose a default only when one answer is right for most.

Do not:
- Do not use it for a product colour or size. That is VariationPicker.
- Do not lay radio buttons out without their fieldset and legend.

Accessibility:
- One fieldset with one legend, so a screen reader says what the options are for.
- Native radio buttons: arrow keys move, a form posts the value.

## ErrorSummary

What a rejected form says first: every problem, each a link to its field.

Group: Forms. Code: `components/software/form.tsx`. From the old system: ErrorSummary in @id-identity-as/ui/form. Live: https://design.id-hub.dk/software/error-summary

```tsx
import { ErrorSummary } from '@/components/software/form';

<ErrorSummary
  title="Ret 2 felter"
  errors={[
    { id: 'email', message: 'Skriv en e-mailadresse' },
    { id: 'cvr', message: 'CVR-nummeret skal have otte cifre' },
  ]}
/>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| title (required) | `string` |  | The heading, such as "Ret 2 felter". Written by the page, so it can be translated and counted. |
| errors (required) | `Array<{ id: string; message: string }>` |  | One line per field: the id of the field and what to do. An empty list renders nothing. |
| id | `string` | `'error-summary'` | A stable id, so the form can send focus here. |

Do:
- Place it first in the form.
- Send focus to it when the form comes back with errors.
- Repeat each message on its field with the error prop.

Do not:
- Do not use it for what the browser already validates before the form posts.
- Do not colour it red. The doubled edge marks it.

Accessibility:
- role="alert", and it can take focus from script (tabindex -1).
- Every message is a link to its field, so one press moves there.

## QuantityStepper

A number chosen with minus and plus, around a real number field.

Group: Forms. Code: `components/software/quantity-stepper.tsx`. From the old system: QuantityStepper in @id-identity-as/ui/buy. Live: https://design.id-hub.dk/software/quantity-stepper

```tsx
import { QuantityStepper } from '@/components/software/quantity-stepper';

<QuantityStepper label="Antal" name="quantity" min={10} step={10} defaultValue={20} helper="Sælges i kolli a 10." />
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| label (required) | `string` |  | What is counted. |
| name (required) | `string` |  | The form field name. The value posts like any other field. |
| min | `number` | `0` | The lowest number. |
| max | `number` |  | The highest number. |
| step | `number` | `1` | How much one press changes the number. |
| defaultValue | `number` |  | The number from the start. Without it, min. |
| helper | `string` |  | A line under the field. |
| onChange | `(value: number) => void` |  | Called with the new number. |
| labels | `Partial<QuantityStepperLabels>` |  | { decrease, increase }, read aloud for the two buttons. Danish by default. |

Do:
- Use it for small counts that are nudged up and down.
- Say the rule in the helper: the minimum, the pack size.

Do not:
- Do not use it for a number that is typed once, such as a year or a CVR number. That is Input.
- Do not put it in the same row as the solid Button.

Accessibility:
- The field is a native number input with a real label, so 48 can be typed.
- The two buttons are named by labels, and without script the field still works.

## Dialog

A question that must be answered before the work goes on.

Group: Overlays. Code: `components/software/overlay.tsx`. From the old system: Dialog in @id-identity-as/ui/overlay. Live: https://design.id-hub.dk/software/dialog

```tsx
import { Dialog } from '@/components/software/overlay';

<Dialog
  open={open}
  onClose={() => setOpen(false)}
  title="Bekræft ordren"
  description="Antal kan stadig ændres bagefter."
  footer={
    <Actions align="end">
      <Button variant="outline" onClick={() => setOpen(false)}>Annullér</Button>
      <Button onClick={confirm}>Bekræft</Button>
    </Actions>
  }
>
  ...
</Dialog>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| open (required) | `boolean` |  | Whether the dialog is shown. The page owns this state. |
| onClose (required) | `() => void` |  | Called when the dialog closes: the close button, the Escape key or a click outside. |
| title (required) | `string` |  | The name of the dialog, read aloud when it opens. |
| hideTitle | `boolean` | `false` | Hides the title from the eye, when the content is its own heading. |
| description | `string` |  | A line under the title. |
| footer | `ReactNode` |  | The foot of the dialog, usually Actions with the buttons. |
| closeLabel | `string` | `'Luk'` | The name of the close button. |

Do:
- Use it for a decision that cannot wait: confirm, discard, choose.
- Write the title as the question and the buttons as the answers.
- Put the outline action first and the solid one last in the footer.

Do not:
- Do not open a dialog from a dialog.
- Do not use it for a message that needs no answer. That is FlashMessage.
- Do not use it on the public site. A dialog there waits for Figma.

Accessibility:
- The native dialog element, opened as a modal: focus is kept inside, Escape closes it, and the page behind is inert.
- Named by its title and described by its description.
- The close button is an icon with a name.

## Drawer

The same dialog against an edge, as tall as the screen.

Group: Overlays. Code: `components/software/overlay.tsx`. From the old system: Drawer in @id-identity-as/ui/overlay. Live: https://design.id-hub.dk/software/drawer

```tsx
import { Drawer } from '@/components/software/overlay';

<Drawer open={open} onClose={() => setOpen(false)} title="Filtre">
  ...
</Drawer>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| open (required) | `boolean` |  | Whether the drawer is shown. |
| onClose (required) | `() => void` |  | Called when the drawer closes. |
| title (required) | `string` |  | The name of the drawer, read aloud when it opens. |
| side | `'start' \| 'end'` | `'end'` | The edge the drawer comes from. End is the right in a left to right language. |
| hideTitle | `boolean` | `false` | Hides the title from the eye. |
| footer | `ReactNode` |  | The foot of the drawer, such as Actions. |
| closeLabel | `string` | `'Luk'` | The name of the close button. |

Do:
- Use it for filters, for a detail beside a list, and for the menu on a phone.
- Keep the list behind it in place, so closing returns to the same spot.

Do not:
- Do not put a whole flow of several steps in a drawer. Give it a page.
- Do not slide it in with an animation of your own. Motion is not decided yet.

Accessibility:
- The native dialog element, as Dialog: focus is kept inside and Escape closes it.
- Named by its title.

## Tabs

Views of the same thing, one at a time, with the whole keyboard model.

Group: Overlays. Code: `components/software/overlay.tsx`. From the old system: Tabs in @id-identity-as/ui/overlay. Live: https://design.id-hub.dk/software/tabs

```tsx
import { Tabs } from '@/components/software/overlay';

<Tabs
  label="Vis ordren som"
  items={[
    { id: 'lines', label: 'Linjer', content: <Table ... /> },
    { id: 'history', label: 'Historik', content: <Text>...</Text> },
  ]}
/>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| label (required) | `string` |  | The name of the tab list, read aloud. |
| items (required) | `TabItem[]` |  | { id, label, content }. |
| defaultSelectedKey | `string` |  | The tab shown from the start, uncontrolled. Defaults to the first. |
| selectedKey | `string` |  | The tab shown. With onSelectionChange the tabs are controlled. |
| onSelectionChange | `(key: string) => void` |  | Called with the id of the new tab. |

Do:
- Use tabs for views of one thing: the lines and the history of an order.
- Keep the labels to a word or two.
- Control it and keep the choice in the address when a tab should be shareable.

Do not:
- Do not use tabs for navigation between pages. That is Navigation.
- Do not let the tab list wrap. It scrolls sideways.

Accessibility:
- The ARIA tabs pattern: arrow keys move along the list, Home and End jump to the ends.
- Only the chosen tab is in the tab order, and each panel is tied to its tab and can take focus.

## CopyButton

Copies a text to the clipboard and says whether it worked.

Group: Tools. Code: `components/software/tools.tsx`. From the old system: CopyLinkButton in @id-identity-as/ui. Live: https://design.id-hub.dk/software/copy-button

```tsx
import { CopyButton } from '@/components/software/tools';

<CopyButton value={url} copiedLabel="Kopieret" failedLabel="Kunne ikke kopiere">Kopiér link</CopyButton>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| value (required) | `string` |  | The text that is copied, such as a link. |
| copiedLabel (required) | `string` |  | What the button says once the text is copied. |
| failedLabel (required) | `string` |  | What the button says when the browser refuses. |
| children (required) | `ReactNode` |  | The label of the button. |

Do:
- Say what is copied in the label: "Kopiér link".
- Show the text that is copied nearby, so it can also be selected by hand.

Do not:
- Do not copy without a press.
- Do not hide a failure. A copy that did not happen says so.

Accessibility:
- The outcome is announced politely to a screen reader.
- It is the outline Button, so the keyboard works as on any button.

## PrintButton

Opens the print dialog of the browser, and stays out of the print itself.

Group: Tools. Code: `components/software/tools.tsx`. From the old system: PrintButton in @id-identity-as/ui. Live: https://design.id-hub.dk/software/print-button

```tsx
import { PrintButton } from '@/components/software/tools';

<PrintButton>Udskriv ordren</PrintButton>
```

| Prop | Type | Default | What it does |
| --- | --- | --- | --- |
| children (required) | `ReactNode` |  | The label of the button. |

Do:
- Use it on a page made to be printed: an order, a list, a report.
- Say what is printed in the label.

Do not:
- Do not use it for brochures or brand print. Those follow the brochure rules.

Accessibility:
- The outline Button. It is hidden in print, so it never appears on paper.

## What became of the old system

The old React catalogue: https://id-partner-room.vercel.app/brand/react. What was carried over is named on each component. The rest:

| In the old system | Now | Why |
| --- | --- | --- |
| Button variants ghost, approve and reject, the small size and the pending prop | Button from Figma: solid and outline. | Figma draws two variants and no states yet (question 7). Approve and reject are words on a solid and an outline Button. A wait is aria-busy on the button and a PendingNote beside it. |
| Container, Bleed, Section | Grid and Stack. | The page width, the margins and the breakpoints are not in Figma yet (question 10). The grid runs across the whole width with no gutter. |
| Eyebrow | The eyebrow prop on CardHeader, or Text in the muted tone. | The mono capitals of the old overline are not a text style in Figma. |
| Badge variants nyhed, bestseller, eco, campaign, signal, info, success, warning, danger | Badge: outline, solid and tint. | There are no status or commerce colours in Figma. The word carries the meaning. |
| StatCard sparkline and the green or red delta chip | StatCard with the change as text and an arrow. | No pasted svg, and no status colours. |
| ChartFrame, TimeSeriesChart, CategoryBarChart, ShareDonut, SERIES | Not carried over. BarList covers a ranked list. | Figma has no chart colours. Ask before a chart is built. |
| ProductCard, ProductGrid, ProductGridItem, ProductImage, ProductImagePlaceholder, image-contract | ProductCard from Figma. | The product card is drawn in Figma. Packshots sit on Snow, uncropped. |
| SizeChoice | VariationPicker from Figma. | The variant selector is drawn in Figma, with the brackets. |
| DealerPrice, StockIndicator, ArticleNumber, CertBadgeRow, VolumePriceTable, FreightProgress, SizeGuideTable, NotifyMe, BuyBar, QuickBuy, SearchSuggest, FilterBar, FilterPanel, SortSelect, ShowMore | Not carried over. | They belong to the public shop. They are drawn in Figma first, and they are on the list of what id-site needs. |
| Hero, HeroMedia, EditorialSplit, EditorialMedia, StatsBand, GarmentStrip, NewsletterSignup, Footer, ErrorPage, CookieConsent, and the public site Navigation | Not carried over. Navigation here is the plain list of links for an app. | They are the face of the public site. They are drawn in Figma first. |
| Icon, ICONS (49 icons), IDLogo | Icon from Figma (21 icons). The logo is in public/brand. | The icon set is closed and comes from Figma. A missing icon is drawn there first. |
