Zum Inhalt springen

Komponenten

Zusammenstellung

Die gebündelten UI-Komponenten sind dafür gedacht, zusammengesetzt zu werden, statt einzeln zum Einsatz zu kommen. Eine Auswahl öffnet sich in einem Dialog, ein Formular wird in einer Seitenleiste validiert, ein Menü sitzt in einer Tabellenzeile. Diese Seite erklärt die Mechanismen, die dafür sorgen, dass alles zusammenpasst: den Aufbau zusammengesetzter Komponentenfamilien, die Weitergabe von Button-Props durch Trigger, die Aufgaben des Interactivity-API im Hintergrund und das Ebenenmodell, das gestapelte Oberflächen zusammenhält.

Zusammengesetzte Komponentenfamilien

Eine zusammengesetzte Komponente besteht aus einem Stammblock und untergeordneten Blöcken. Der Stammblock verwaltet den Zustand. Jeder untergeordnete Block gibt über parent und usesContext in seiner block.json an, welchen Platz er in der Familie einnimmt:

JSON
{
  "name": "bsui/select-option",
  "parent": ["bsui/select-popup"],
  "usesContext": ["bsui/select"]
}

Stammblöcke stellen einen InnerBlocks-Bereich mit einer allowedBlocks-Liste und einer anfänglichen template bereit. Wenn du also im Editor einen Dialog einfügst, werden sein Trigger, der Hintergrund und das Popup angelegt. Eine Komponentenfamilie verhält sich gleich, egal ob sie im Editor, auf einer dateibasierten Seite oder in Tags zusammengesetzt wird:

HTML
<bs:bsui-select name="role" placeholder="Pick a role">
  <bs:bsui-select-trigger />
  <bs:bsui-select-popup>
    <bs:bsui-select-option value="viewer" label="Viewer" />
    <bs:bsui-select-option value="editor" label="Editor" />
  </bs:bsui-select-popup>
</bs:bsui-select>

Popups und Bedienfelder sind echte InnerBlocks-Bereiche und keine Slots mit spezieller Syntax. Ein bsui/dialog-popup akzeptiert verschachtelte Blöcke genauso wie ein Gruppenblock. Dadurch lassen sich Formulare, Auswahlfelder oder weitere Dialoge ganz normal darin zusammensetzen.

Flache Daten oder zusammengesetzte untergeordnete Elemente

Manche Komponentenfamilien nehmen ihre Inhalte als Daten statt als untergeordnete Elemente entgegen. Wenn du dem Auswahlfeld ein Array aus options JSON übergibst, erstellt es seinen Trigger und seine Listbox selbst. Das eignet sich für Optionen aus PHP:

PHP
bs_render_block([
  'name' => 'bsui/select',
  'data' => [
    'name' => 'role',
    'placeholder' => 'Pick a role',
    'options' => wp_json_encode([
      ['value' => 'viewer', 'label' => 'Viewer'],
      ['value' => 'editor', 'label' => 'Editor'],
    ]),
  ],
]);

Beide Formen erzeugen denselben Markup-Vertrag und dasselbe Laufzeitverhalten. Verwende untergeordnete Elemente, wenn die Struktur direkt erstellt wird, und options, wenn sie berechnet wird.

Trigger-Weitergabe

Overlay-Komponenten werden über einen Button geöffnet, und dieser Button sollte der System-Button sein. Statt für jeden Trigger einen eigenen Button neu zu implementieren, binden die Triggerblöcke von bsui/dialog, bsui/alert-dialog, bsui/drawer, bsui/menu, bsui/popover, bsui/collapsible und bsui/tooltip den bsui/button über ein Block-Feld ein:

JSON
{
  "blockstudio": {
    "attributes": [
      {
        "id": "trigger",
        "type": "block",
        "block": "bsui/button",
        "idStructure": "trigger_{id}"
      }
    ]
  }
}

Die idStructure überträgt die Felder des Buttons mit dem Präfix trigger_ auf den Trigger. Alle Button-Props sind verfügbar: trigger_label, trigger_variant, trigger_size, trigger_icon, trigger_iconPosition, trigger_href, trigger_disabled.

HTML
<bs:bsui-dialog-trigger trigger_label="Invite teammate" trigger_variant="outline" />

In der Vorlage des Triggers ist $a['trigger'] der vollständig gerenderte Button, sodass sein Stylesheet und künftige Verbesserungen mit übernommen werden. Zur Laufzeit überträgt ein gemeinsamer Helper die ARIA-Verknüpfungen des Wrappers (aria-haspopup, aria-expanded, aria-controls, aria-describedby, aria-labelledby, id) auf den inneren Button und hält sie über ein MutationObserver synchron, sodass assistive Technologien ein einziges, konsistentes Steuerelement erkennen.

Der Interactivity-API im Hintergrund

Jede interaktive Komponentenfamilie ist ein WordPress-Interactivity-API-Store, benannt nach ihrem Stammblock: bsui/dialog, bsui/select, bsui/form, bsui/tabs und so weiter. Daraus ergeben sich drei Folgen.

Der Zustand wird serverseitig initialisiert. Die Vorlage des Stammblocks gibt den Anfangszustand direkt aus den Attributen des Blocks als data-wp-context aus:

HTML
<div
  data-wp-interactive="bsui/select"
  data-wp-context='{"open":false,"value":"","placeholder":"Pick a role", ...}'
  data-bsui-select-root
>

Die Seite wird sofort korrekt angezeigt HTML, ohne kurzzeitiges Flackern während der clientseitigen Hydrierung. Popups starten hidden, und dasselbe Markup funktioniert im Editor-Canvas, weil der Kontext nicht von einem nur im Frontend ausgeführten Zustandsschritt abhängt.

Das Verhalten wird über Direktiven statt über dein JavaScript verknüpft. Die Vorlagen verbinden Markup deklarativ mit Stores. Ohne sein PHP besteht der Trigger des Auswahlfelds nur aus Direktiven:

HTML
<button
  data-wp-interactive="bsui/select"
  data-wp-on--click="actions.toggle"
  data-wp-on--keydown="actions.handleTriggerKeyDown"
  data-wp-bind--aria-expanded="state.ariaExpanded"
  data-wp-text="state.displayValue"
  data-bsui-select-trigger
  aria-haspopup="listbox"
>

data-wp-on leitet Ereignisse an Aktionen weiter, data-wp-bind hält Attribute mit dem abgeleiteten Zustand synchron, data-wp-text gibt den Zustand als Text aus und data-wp-on-document--click sorgt dafür, dass Stammblöcke bei einem Klick außerhalb geschlossen werden. Beim Zusammensetzen von Komponenten musst du nie einen Event-Handler schreiben. Der Store wird als Inline-Modul zusammen mit dem Block ausgeliefert.

Deine Stores lassen sich in die Verbindungen einfügen. Formularsteuerelemente akzeptieren Direktivausdrücke als Attribute, und die namensraumbasierte Syntax des Interactivity-API verweist sie auf jeden Store. onChange leitet die Änderungsbehandlung an eine deiner Aktionen weiter, checked bindet den Zustand des Steuerelements an deinen Zustand, und bindText gibt eine Beschriftung als data-wp-text-span aus, das an einen beliebigen Zustandspfad gebunden ist:

HTML
<bs:bsui-switch label="Notifications" checked="myPlugin::state.notifications" onChange="myPlugin::actions.toggleNotifications" />
<bs:bsui-checkbox label="0 selected" bindText="myPlugin::state.selectionSummary" />

bindText ist bei Elementen von bsui/label, bsui/checkbox, bsui/switch, bsui/toggle und bsui/radio-group verfügbar. Bei Checkbox-, Schalter- und Optionsfeld-Elementen wird es an das gemeinsame Beschriftungselement weitergereicht, sodass zustandsgesteuerter Text exakt die Typografie der Systembeschriftung verwendet. Auswahlfelder und andere Eingaben lösen außerdem ein bubbling change-Ereignis am Stamm aus, das den neuen Wert in detail enthält. So sind auch gröber abgestufte Integrationen möglich.

Kontrollierte Werte

Lass value oder checked für ein Steuerelement, das seinen Wert selbst verwaltet, unset. Verwende defaultValue, defaultChecked oder bei Toggle defaultPressed für die anfängliche Auswahl. Ein eigenständiges Toggle verarbeitet Maus- und Tastatureingaben auch ohne Consumer-Store.

Um ein Feld über deinen eigenen Store zu steuern, gib sowohl die Bindung als auch eine onChange-Aktion an, die den gebundenen Wert aktualisiert. value ist ein Direktivenpfad, kein wörtlicher Standardwert. Input, Textarea, Password Input, Number Field, Slider, Radio Group, Color Picker, Rating und Time Picker unterstützen value. Checkbox, Switch und Toggle verwenden stattdessen checked.

Gib Pfade mit dem zugehörigen Namespace an, zum Beispiel my/settings::context.quantity oder my/settings::state.quantity. Zusammengesetzte Steuerelemente haben einen eigenen Namespace. Ein nicht qualifizierter Pfad verweist auf dieses Steuerelement und nicht automatisch auf deinen übergeordneten Store. Zusammengesetzte Wertbindungen unterstützen Punktpfade in Kontext oder Zustand, einschließlich numerischer Array-Schlüssel, aber keine JavaScript-Ausdrücke oder Funktionsaufrufe.

Hier siehst du eine vollständige Number-Field-Bindung in einem benutzerdefinierten Block mit aktivierter Unterstützung für Interactivity API:

PHP
<div
  data-wp-interactive="my/settings"
  data-wp-context='<?php echo esc_attr(wp_json_encode(['quantity' => 2])); ?>'
>
  <bs:bsui-number-field
    nameAlt="quantity"
    defaultValue="2"
    value="my/settings::context.quantity"
    onChange="my/settings::actions.setQuantity"
  />
  <output data-wp-text="context.quantity"></output>
</div>
JavaScript
import { getContext, store } from '@wordpress/interactivity';

store('my/settings', {
  actions: {
    setQuantity(event) {
      // Compound controls publish their normalized value in a custom change event.
      if (event.detail?.value !== undefined) {
        getContext().quantity = event.detail.value;
      }
    },
  },
});

Lege den passenden Standardwert für den serverseitig gerenderten Anfangswert fest. Nach der Hydrierung aktualisieren Änderungen am übergeordneten Element jede gebundene Instanz, einschließlich der Werte 0, false und leer. Auch die verborgenen Formulareingaben von Checkbox und Switch folgen ihrer checked-Bindung. Time-Picker-Werte verwenden HH:MM im 24-Stunden-Format oder eine leere Zeichenfolge. Lies für native Handler von Input, Textarea und Password Input den Wert aus event.target.value; zusammengesetzte Wert-Steuerelemente veröffentlichen event.detail.value. Die Grenzwerte von Number Field sind optional: Wenn min und max nicht angegeben sind, gibt es keine Grenzen; eine explizite Null bleibt ein gültiger Grenzwert.

Select, Date Input, Phone Input und OTP Input veröffentlichen Änderungen über onChange, stellen diese kontrollierte value-Bindung jedoch nicht bereit. Verwende ihre dokumentierten Standardwerteigenschaften für Anfangswerte.

Zusammensetzen mit eigenen Blöcken

Das Zusammensetzen ist nicht auf Seiten beschränkt. Block-Tags werden automatisch innerhalb von Blockvorlagen gerendert, sodass ein Projektblock bsui-Komponenten direkt ausgeben und in die eigene Struktur einbetten kann:

PHP
<div useBlockProps class="settings-panel">
  <bs:bsui-switch label="Public profile" name="public" />
  <bs:bsui-space size="4" />
  <bs:bsui-button label="Save" variant="default" />
</div>

Dasselbe funktioniert mit PHP und bs_block(), auch verschachtelt über den Schlüssel content, wie unter Programmatisches Rendering beschrieben. In beiden Fällen werden das Stylesheet und der Store der Komponente mitgeladen, und dein Block bleibt eine schlanke Anordnungsschicht über den Systemkomponenten.

Um Komponenten nebeneinander anzuordnen, dient bsui/stack als allgemeine Flex-Zeile oder -Spalte: direction, gap auf der Abstandsskala, align, justify und ein wrap-Schalter. Untergeordnete Elemente behalten standardmäßig ihre natürliche Größe. Der grow-Schalter dehnt sie so, dass sie die Länge des Stapels gleichmäßig teilen. So können in einer Fußzeile zwei Buttons die Breite aufteilen, statt an einem Ende zusammengedrängt zu sein.

Feldgruppen und Karten

bsui/field-group rendert einen Fieldset. Die Standardvariante gruppiert zusammengehörige Felder, ohne eine Oberfläche hinzuzufügen. Verwende variant="card" für einen dezenten äußeren Rahmen und platziere die Felder anschließend in bsui/field-group-content, um eine eingelassene Inhaltsfläche zu erhalten. Titel und Beschreibung bleiben außerhalb dieses Inhaltsblocks:

HTML
<bs:bsui-field-group variant="card">
  <bs:bsui-field-group-title text="Account settings" />
  <bs:bsui-field-group-description text="Manage your account preferences." />
  <bs:bsui-field-group-content>
    <bs:bsui-field>
      <bs:bsui-field-label text="Display name" />
      <bs:bsui-input nameAlt="display_name" placeholder="Enter display name" />
    </bs:bsui-field>
    <bs:bsui-field>
      <bs:bsui-field-label text="Email" />
      <bs:bsui-input nameAlt="email" type="email" placeholder="Enter email" />
    </bs:bsui-field>
  </bs:bsui-field-group-content>
</bs:bsui-field-group>

disabled="true" in der Gruppe verwendet das native Fieldset-Verhalten, um die Formularsteuerelemente zu deaktivieren. Das Karten-Styling ändert die Standardvariante nicht.

Trennlinien in der Werkzeugleiste

Platziere bsui/toolbar-separator zwischen den Elementen der Werkzeugleiste. Es richtet sich nach orientation der übergeordneten Werkzeugleiste: Eine horizontale Werkzeugleiste erhält eine vertikale Trennlinie über die volle Höhe, eine vertikale Werkzeugleiste eine horizontale Trennlinie über die volle Breite. Die Trennlinien reichen bis zu den Innenkanten des Werkzeugleistenrahmens, ohne die Höhe der Steuerelemente zu verändern. Eine horizontale Werkzeugleiste wird scrollbar, wenn ihr Inhalt die verfügbare Breite überschreitet.

Das Ebenenmodell

Bei gestapelten Oberflächen geraten Komponentenbibliotheken oft ins Straucheln. Die gebündelten Komponenten folgen wenigen Regeln, die für den Einsatz in echten UIs gedacht sind.

Modale Dialoge werden in den body verschoben

Wenn sich ein Dialog, ein Bestätigungsdialog oder eine Seitenleiste öffnet, werden Popup und Hintergrund nach document.body verschoben. Ein Platzhalterkommentar markiert den ursprünglichen Ort für das Schließen. Durch das Verschieben ist der modale Dialog von overflow, Transformationen und Stacking-Kontexten seiner übergeordneten Elemente unabhängig. Beim Öffnen wird außerdem das Scrollen der Seite gesperrt. Die Sperre wird für alle Overlay-Komponenten gemeinsam gezählt und gleicht die Breite der Scrollleiste aus, damit sich die Seite nicht verschiebt. Der Hintergrund liegt bei z-index: 50, das Popup bei 51. Der Fokus wandert ins Popup, Tab bleibt darin gefangen, und beim Schließen kehrt der Fokus zum Trigger zurück.

Modale Dialoge lassen sich stapeln. Wird innerhalb eines Dialogs ein weiterer geöffnet, kommt er auf einen gemeinsamen Stapel. Nur der äußerste Dialog zeigt seinen Hintergrund, und die Dialoge hinter dem obersten werden verkleinert und schauen dahinter hervor. Der Stapel steuert eine benutzerdefinierte --bs-ui-nested-dialogs-Eigenschaft für jedes Popup im Hintergrund, sodass sich Versatz und Skalierung mit jeder Ebene verstärken. Das übergeordnete Element passt seine Höhe an das untergeordnete an, damit die Ebenen gleichmäßig hervorschauen. Beim Schließen wird alles in umgekehrter Reihenfolge wiederhergestellt, eine Ebene pro Schließen.

Beim Schließen eines modalen Dialogs kehrt der Fokus zu seinem Trigger zurück, und zwar zum richtigen Element. Ein gemeinsamer getAnchor-Helper löst einen Trigger-Wrapper zum darin enthaltenen System-Button auf, sodass das sichtbare Steuerelement den Fokus zurückerhält und nicht ein unsichtbarer Wrapper.

Der oberste modale Dialog wird nie transformiert

Der Effekt, bei dem Dialoge hervorschauen, transformiert nur die Dialoge im Hintergrund. Der oberste modale Dialog bleibt bewusst ohne Transformation, denn ein transformiertes Element wird zum Containing Block für position: fixed-Nachfahren. Das würde jedes darin geöffnete schwebende Popup beeinträchtigen.

Diese Regel sorgt dafür, dass sich das gesamte Ebenenmodell zusammensetzen lässt. Die schwebenden Ebenen positionieren sich alle mit festen Koordinaten. Diese beziehen sich nur dann auf den Viewport, wenn keine Transformation eines übergeordneten Elements dazwischenkommt:

  • Menü und Kombinationsfeld berechnen ihre Position relativ zum Trigger mit der Strategie fixed von Floating UI. Sie öffnen sich darunter und werden nach oben oder zur Seite verschoben, wenn der Platz im Viewport knapp wird.
  • Das Auswahlfeld verhält sich genauso, wenn nichts ausgewählt ist. Bei einer vorhandenen Auswahl richtet es das Popup stattdessen so aus, dass die ausgewählte Option direkt über dem Trigger liegt und im Viewport bleibt, wie bei nativen Auswahlfeldern unter macOS.
  • Das Kontextmenü öffnet sich an den clientX/clientY des Mauszeigers.

Da der oberste modale Dialog nicht transformiert wird, sind alle diese Elemente korrekt an ihren Triggern innerhalb eines Dialogs, Bestätigungsdialogs oder einer Seitenleiste verankert, unabhängig von der Verschachtelungstiefe. Die Popups müssen nicht wissen, dass sie sich in einem modalen Dialog befinden.

Escape schließt zuerst die innerste Ebene

Einmal Escape drücken schließt genau eine Ebene, von innen nach außen:

  1. Eine geöffnete schwebende Ebene (eine Listbox eines Auswahlfelds, ein Menü, ein Popover, ein Datums- oder Telefon-Popup) wird zuerst geschlossen, und der Fokus kehrt zu ihrem Trigger zurück. Das Auswahlfeld stoppt die Weitergabe des Ereignisses, und die Handler des modalen Dialogs reagieren ebenfalls nicht, solange eine schwebende Ebene geöffnet ist. Der darunterliegende Dialog bekommt diesen Tastendruck daher nie zu sehen.
  2. Danach wird der oberste modale Dialog geschlossen.
  3. Bei gestapelten modalen Dialogen wird mit jedem weiteren Escape ein weiterer vom Stapel entfernt.

Das Schließen folgt einer Regel und geschieht nicht zufällig. Ein mit dismissable="false" gerenderter Dialog ignoriert sowohl Escape als auch Klicks auf den Hintergrund. Und bsui/alert-dialog reagiert auf Escape wie jeder modale Dialog, ignoriert aber bewusst Klicks auf den Hintergrund: Bei diesem Muster muss die Entscheidung bewusst getroffen werden, statt dass es versehentlich geschlossen wird. Klicks auf den Hintergrund schließen einen normalen Dialog, da dismissable standardmäßig auf true gesetzt ist.

Ein Formular in einem Dialog

Dieses Muster vereint alle oben beschriebenen Regeln: Ein Trigger öffnet einen modalen Dialog, der ein Formular mit Validierung enthält, und im Formular befindet sich ein schwebendes Auswahlfeld.

HTML
<bs:bsui-dialog>
  <bs:bsui-dialog-trigger trigger_label="Invite teammate" trigger_variant="outline" />
  <bs:bsui-dialog-backdrop />
  <bs:bsui-dialog-popup>
    <bs:bsui-dialog-header>
      <bs:bsui-dialog-title content="Invite a teammate" />
      <bs:bsui-dialog-description content="They receive an email with a join link." />
    </bs:bsui-dialog-header>
    <bs:bsui-dialog-content>
      <bs:bsui-form block="team/invite" successMessage="Invitation sent.">
        <bs:bsui-field name="email">
          <bs:bsui-field-label text="Email" />
          <bs:bsui-input name="email" type="email" placeholder="colleague@example.com" required="true" />
          <bs:bsui-field-error />
        </bs:bsui-field>
        <bs:bsui-field name="role">
          <bs:bsui-field-label text="Role" />
          <bs:bsui-select name="role" defaultValue="editor" placeholder="Pick a role">
            <bs:bsui-select-trigger />
            <bs:bsui-select-popup>
              <bs:bsui-select-option value="viewer" label="Viewer" />
              <bs:bsui-select-option value="editor" label="Editor" />
              <bs:bsui-select-option value="admin" label="Admin" />
            </bs:bsui-select-popup>
          </bs:bsui-select>
        </bs:bsui-field>
        <bs:bsui-space size="2" />
        <bs:bsui-button label="Send invite" />
      </bs:bsui-form>
    </bs:bsui-dialog-content>
    <bs:bsui-dialog-footer>
      <bs:bsui-dialog-close label="Cancel" />
    </bs:bsui-dialog-footer>
  </bs:bsui-dialog-popup>
</bs:bsui-dialog>

Jedes Tag und Attribut oben ist wichtig: Der Trigger leitet an den System-Button weiter, Titel und Beschreibung erhalten content, die Felder tragen die Namen, unter denen das Formular sie serialisiert, und required="true" wird im Tag-Parser in einen echten Boolean umgewandelt.

Was jeder Store zur Laufzeit macht

bsui/dialog fügt {"open":false,"dismissable":true} dem Kontext auf dem Server hinzu. Der Klick auf den Auslöser führt actions.open aus: Popup und Hintergrundebene werden in den Body verschoben, das Scrollen wird mit einem Ausgleich für die Scrollleiste gesperrt, das Popup wird innerhalb von 150ms eingeblendet, der Fokus wechselt zum ersten fokussierbaren Element und Tab bleibt innerhalb des Popups. Kopfzeile, Inhalt und Fußzeile halten anhand der Modal-Abstandstokens den Abstand zueinander.

bsui/select wartet mit seiner Listbox hidden im Formular. Ein Klick auf den Auslöser schaltet context.open um, positioniert die Listbox mit festen Viewport-Koordinaten und richtet das Popup, da defaultValue="editor" bereits ausgewählt ist, so aus, dass Editor direkt über dem Auslöser sitzt. Pfeiltasten, Pos1, Ende und Texteingabe ändern die aktive Option; Enter oder ein Klick wählt sie aus; Tab und Klicks außerhalb schließen das Menü, ohne eine Option auszuwählen. Der sichtbare Text des Auslösers wird über data-wp-text="state.displayValue" aktualisiert, und das verborgene <input name="role"> übernimmt den Wert über data-wp-bind--value="state.selectedValue", den das Formular später serialisiert. All das wird innerhalb des Dialogs korrekt verankert, weil das oberste Modal nicht transformiert ist.

bsui/form fängt das Absenden ab. Das bsui/button am Ende des Formulars rendert ein einfaches button-Element ohne type-Attribut und ist daher standardmäßig nach HTML das Absende-Steuerelement des Formulars; die Schaltfläche „Abbrechen“ befindet sich in der Fußzeile außerhalb des form-Elements und kann nichts absenden. Beim Absenden serialisiert der Store die FormData des Formulars und sendet sie über die Daten-API des in block genannten Blocks. Hier wird damit ein Eintrag im Datenbankschema des team/invite-Blocks erstellt. Validierungsfehler werden für jedes Feld zurückgegeben: Jedes bsui/field enthält sein name, wird als ungültig markiert, der Fokusring erhält die Warnfarbe und die Meldung erscheint in seiner bsui/field-error-Warnung. Bei Erfolg wird der Formularinhalt ausgeblendet und das successMessage eingeblendet, beides über data-wp-bind--hidden.

Die Ebenen schließen sich der Reihe nach. Ist die Listbox geöffnet, schließt Escape zuerst die Listbox und setzt den Fokus wieder auf den Auswahl-Auslöser; mit dem nächsten Escape schließt sich der Dialog und der Fokus kehrt zu „Teammitglied einladen“ zurück. Ein Klick auf die Hintergrundebene schließt den Dialog, da dismissable auf dem Standardwert belassen wurde. Beim Schließen wird die Scrollsperre aufgehoben und das Popup an seine ursprüngliche Stelle im Dokument zurückverschoben.

Wird dasselbe Markup in eine dateibasierte Seite eingefügt, wird es mit nativen Blöcken synchronisiert. Dieselbe Komposition lässt sich im Editor interaktiv auf der Arbeitsfläche ansehen, weil alle oben beschriebenen Verhaltensweisen in Direktiven und Stores liegen, die in beiden Kontexten geladen werden.

Was diese Übergänge zuverlässig macht

Die beschriebenen Übergänge sind keine Konventionen, sondern Invarianten, die die Bibliothek überall beim Rendern gewährleistet: Jedes Label wird derselben Typografie zugeordnet, jedes Modal-Popup hat dieselbe Oberfläche und dunkelt die Seite dahinter ab, schwebende Popups bleiben beim Scrollen der Seite am Auslöser verankert und Escape schließt genau eine Ebene auf einmal, von innen nach außen. Diese Garantien gelten im Frontend und auf der Arbeitsfläche des Editors, sowohl mit den Standardtokens als auch mit denen deines Themes. Eine Komposition, die in einem Kontext funktioniert, verhält sich also auch in den anderen gleich.

Live-Beispiele

Die Kompositionen auf dieser Seite zeigen die Grammatik; /ui/examples ist das Phrasenbuch. Es versammelt live gerenderte Kompositionen in drei Stufen: Kombinationen, die einen Übergang zwischen zwei oder drei Komponenten veranschaulichen, bekannte Produktmuster aus einigen Komponenten und vollständige Mini-Apps, zusammengesetzt wie in echten Produkten. Jede Komponentenseite unter /ui bietet weitere ausgearbeitete Beispiele, vom beschrifteten Feld bis zum Kalender hinter einem Popover.

Interaktivität

Die Direktiven und das Store-Modell, auf denen die UI-Komponenten basieren, und wie du sie in deinen eigenen Blöcken verwendest.