Zum Inhalt springen

Dennis · 14. März 2026

Blockstudio 7.1

Blockstudio 7.1 ist das erste Funktionsupdate seit der Neufassung von v7. Während v7 das Fundament erneuert hat, ergänzt 7.1 die Bausteine, die Blöcke zu mehr machen: eine Datenbankschicht, Serverfunktionen, geplante Aufgaben und eine CLI. Ein Blockordner kann jetzt eine vollständige Anwendung sein.

Hier sind alle Neuerungen.

Komponenten

Schon immer gab es eine Spannung zwischen Blöcken, die Redakteure im Inserter verwenden, und Blöcken, die Entwickler als Bausteine für andere Dinge nutzen. Eine Karte, ein Badge, ein Statistik-Widget, ein Formulareingabefeld. Sie benötigen die vollständige Blockstudio-Pipeline (Attribute, Vorlagen, Assets, Tailwind), haben aber im Inserter nichts zu suchen.

7.1 führt Komponenten ein, um dieses Problem zu lösen. Setze "component": true in deiner block.json, und der Block durchläuft die gesamte Build-Pipeline, wird aber nie in der Blocktyp-Registry von WordPress registriert. Er erscheint nicht im Inserter und nicht in den an JavaScript gesendeten Editor-Daten, steht aber für das programmatische Rendern vollständig zur Verfügung.

JSON
{
  "name": "my-theme/card",
  "title": "Card",
  "blockstudio": {
    "component": true,
    "attributes": [
      { "id": "title", "type": "text" },
      { "id": "description", "type": "textarea" }
    ]
  }
}

Rendere sie über PHP:

PHP
bs_render_block([
  'name' => 'my-theme/card',
  'data' => ['title' => 'My Card', 'description' => 'Card content.'],
]);

Oder mit der neuen HTML-Tag-Syntax:

HTML
<bs:my-theme-card title="My Card" description="Card content." />

Block-Tags

Blöcke lassen sich jetzt als HTML-Tags mit zwei austauschbaren Syntaxvarianten einbetten:

HTML
<bs:acme-hero title="Welcome" />
<block name="acme/hero" title="Welcome" />

Beide erzeugen dieselbe Ausgabe. Beide funktionieren mit Blockstudio-Blöcken und mit den WordPress-Kernblöcken. Innerhalb von Blockvorlagen werden sie automatisch gerendert, ohne dass du etwas aktivieren musst. So kannst du ganze Layouts direkt in deiner Vorlage aus anderen Blöcken zusammensetzen:

Twig
<div class="my-page">
  <bs:mytheme-card title="Featured" />
  <block name="core/separator" />
  <bs:core-heading level="2">Section Title</bs:core-heading>
  <block name="core/group">
    <block name="core/paragraph">Inside a core group block.</block>
    <bs:mytheme-cta variant="primary" />
  </block>
</div>

Die beiden Syntaxvarianten lassen sich beliebig ineinander verschachteln. Blockstudio-Blöcke durchlaufen die vollständige Pipeline (Vorlagen, Tailwind, Assets). Kernblöcke werden über WordPress mit denselben Renderern ausgegeben, die auch Pages and Patterns antreiben.

Aktiviere das Rendern auf Seitenebene (Beitragsinhalte, Widget-Bereiche) in blockstudio.json:

JSON
{ "blockTags": { "enabled": true } }

Mit Zulassungs- und Sperrlisten steuerst du über Platzhaltermuster, welche Blöcke sich per Tag rendern lassen. Die Attribute data-* und html-* werden an das HTML-Element des gerenderten Blocks weitergegeben. Benutzerdefinierte Renderer lassen sich über den Filter blockstudio/block_tags/renderers registrieren.

Unter der Haube ersetzt ein neuer, schlanker String-Scanner den Einsatz von DOMDocument vollständig. Er verarbeitet verschachtelte Tags mit Tiefenverfolgung, rekursive Containerblöcke und gemischte Syntax in einem Durchlauf. In Benchmarks parst er 1.000 einfache Tags in 2,4 ms und 100 Verschachtelungsebenen in 3,7 ms und ist damit durchgehend schneller als DOMDocument und WordPress’s WP_HTML_Tag_Processor. Derselbe Parser übernimmt auch das Parsen roher HTML-Elemente für Pages and Patterns und ersetzt den DOMDocument-basierten Parser, der bisher <p>, <div> und andere HTML-Elemente verarbeitet hat.

Neue Feldtypen

Block

Ein neuer Feldtyp block, mit dem du einen anderen Blockstudio-Block als Attribut referenzieren kannst. Die Felder des referenzierten Blocks werden mit idStructure und overrides direkt eingefügt, genau wie benutzerdefinierte Felder. Der Unterschied: Greifst du in der Vorlage auf den Wert zu, erhältst du die gerenderte Blockausgabe.

JSON
{
  "blockstudio": {
    "attributes": [
      {
        "id": "card",
        "type": "block",
        "block": "mytheme/card",
        "idStructure": "card_{id}"
      }
    ]
  }
}

Wenn mytheme/card die Felder heading und content hat, erhält der Host-Block card_heading und card_content in seiner Seitenleiste. In der Vorlage gibt {{ a.card }} die gerenderte Karte aus. Funktioniert sowohl mit regulären Blöcken als auch mit Komponenten.

HTML-Tag

In jedem Theme gibt es Blöcke, deren Überschriftenebene sich je nach Kontext ändern sollte. Eine H1 auf der Startseite, eine H2 auf Unterseiten. Statt dafür jedes Mal ein Auswahlfeld mit fest codierten Optionen zu erstellen, gibt es jetzt einen eigenen Feldtyp html-tag mit integrierten Voreinstellungen.

JSON
{
  "id": "tag",
  "type": "html-tag",
  "default": "h2",
  "tags": "heading",
  "exclude": ["h5", "h6"]
}

Voreinstellungen: heading (h1–h6), text (Überschriften + p, span, div), structural (div, section, article, aside, main, header, footer, nav), all. Du kannst auch ein eigenes Array übergeben. Mit exclude entfernst du bestimmte Tags aus jeder Voreinstellung.

Twig
<{{ a.tag }}>{{ a.title }}</{{ a.tag }}>

Datenbank

Das ist das Herzstück dieses Releases. Füge eine db.php-Datei zu einem beliebigen Blockverzeichnis hinzu, und Blockstudio erstellt fünf REST-CRUD-Endpunkte, validiert jeden Schreibvorgang anhand des Schemas, verwaltet das Speicher-Backend automatisch und stellt sowohl einen JavaScript-Client (bs.db()) als auch ein PHP API (Db::get()) bereit. Keine Migrationsdateien, keine Controller-Klassen, keine Routeneinträge.

PHP
return [
    'subscribers' => [
        'storage'    => 'table',
        'capability' => [
            'create' => true,
            'read'   => true,
            'update' => 'edit_posts',
            'delete' => 'manage_options',
        ],
        'fields' => [
            'email' => [
                'type'     => 'string',
                'format'   => 'email',
                'required' => true,
                'validate' => function ($value) {
                    if (str_ends_with($value, '@spam.com')) {
                        return 'This domain is blocked.';
                    }
                    return true;
                },
            ],
            'name' => ['type' => 'string', 'maxLength' => 100],
            'plan' => ['type' => 'string', 'enum' => ['free', 'pro']],
        ],
    ],
];

Allein dieses Schema erzeugt eine vollständig funktionsfähige API mit Endpunkten zum Erstellen, Auflisten, Abrufen, Aktualisieren und Löschen, jeweils mit Eingabevalidierung.

Speicher

Fünf Speicher-Backends, jeweils für unterschiedliche Anwendungsfälle:

  • table: Benutzerdefinierte MySQL-Tabelle, verwaltet über dbDelta(). Neue Felder im Schema fügen beim nächsten Seitenaufruf Spalten hinzu. Der Standard für den Produktivbetrieb.
  • sqlite: Eine einzelne SQLite-Datei im Ordner db/ des Blocks. Echte SQL-Abfragen, WAL-Modus für parallele Lesezugriffe und vollständig portabel. Kopiere den Ordner, kopiere die Datenbank.
  • jsonc: Ein JSON-Objekt pro Zeile in einer einfachen Datei. Menschenlesbar, versionsverwaltbar und git-freundlich.
  • meta: Ein JSON-Array in den Beitrags-Metadaten von WordPress, einem bestimmten Beitrag zugeordnet.
  • post_type: Jeder Datensatz wird zu einem WordPress-Beitrag in einem benutzerdefinierten Beitragstyp. Die Felder werden als einzelne Beitrags-Metadateneinträge gespeichert und lassen sich vollständig mit WP_Query abfragen.

Clients

Auf der JavaScript-Seite stellt dir bs.db() einen vollständigen CRUD-Client bereit:

JavaScript
const db = bs.db('my-theme/block', 'subscribers');
const record = await db.create({ email: 'a@b.com', plan: 'pro' });
const pros = await db.list({ plan: 'pro' });
await db.update(record.id, { plan: 'free' });
await db.delete(record.id);

Dazu kommen drei ergänzende Hilfsfunktionen:

  • bs.cache: Ein In-Memory-Abfrage-Cache mit get, set, invalidate und clear. Wird von allen Abfrage- und Änderungsaufrufen gemeinsam genutzt.
  • bs.query(key, fn, options): Umschließt beliebige asynchrone Funktionen mit Caching, Deduplizierung von Anfragen und konfigurierbarer staleTime. Mehrere Aufrufe mit demselben Schlüssel während einer laufenden Anfrage erhalten dasselbe Promise.
  • bs.mutate(options): Verwaltet optimistische Änderungen mit automatischem Rollback. Übergib ein reaktives Zustandsobjekt, eine Aktion (create, update, delete) und optimistische Daten. Der UI wird sofort aktualisiert. Schlägt der Serveraufruf fehl, wird der Zustand auf den Stand vor der Änderung zurückgesetzt.

Zusammen decken diese den gesamten Lese- und Schreibzyklus ab: bs.query für zwischengespeicherte Lesezugriffe, bs.mutate für optimistische Schreibzugriffe, bs.cache für manuelle Steuerung.

Auf der PHP-Seite bietet die Klasse Db dieselben Vorgänge:

PHP
use Blockstudio\Db;

$db = Db::get('my-theme/block', 'subscribers');
$db->create(['email' => 'a@b.com', 'plan' => 'pro']);
$db->list(['plan' => 'pro']);

Validierung

Validierungsfehler werden als feldbezogene Fehler-Arrays zurückgegeben, angelehnt an das fieldErrors-Format von Zod. Für dasselbe Feld können mehrere Regeln fehlschlagen. Die Struktur erleichtert es, Fehler im Frontend den Formularfeldern zuzuordnen:

JSON
{
  "data": {
    "status": 400,
    "errors": {
      "email": ["Must be a valid email address.", "This domain is blocked."],
      "plan": ["Must be one of: free, pro."]
    }
  }
}

Benutzerdefinierte validate-Callbacks laufen serverseitig und decken Fälle ab, die von den integrierten Regeln nicht erfasst werden: Domainsperren, feldübergreifende Validierung und externe Abfragen.

Benutzerspezifische Daten

Für benutzerspezifische Daten wie Aufgaben, Favoriten oder Entwürfe setzt du userScoped auf true, den Rest übernimmt Blockstudio. Es fügt eine user_id-Spalte hinzu, setzt sie beim Erstellen automatisch und beschränkt jede Abfrage auf den aktuellen Benutzer. Aktualisierungen und Löschvorgänge prüfen die Eigentümerschaft. Kein manuelles Feld user_id, kein Hook before_create und keine Filterung in RPC. Eine Zeile Konfiguration. Bei Verwendung von post_type-Speicher wird userScoped statt einer eigenen Spalte auf post_author abgebildet.

PHP
return [
    'storage'    => 'sqlite',
    'userScoped' => true,
    'fields'     => [ /* ... */ ],
];

Echtzeit-Abfrage

Setze 'realtime' => true in deinem Schema, und der Client fragt Änderungen automatisch ab. Ändert sich etwas auf dem Server, wird der Interactivity-API-Store aktualisiert und UI ohne Änderungen an deinem JavaScript neu gerendert. Mit 'realtime' => ['key' => 'todos', 'interval' => 5000] kannst du eigene Zustandsschlüssel und Intervalle festlegen. Der Abgleich erfolgt per Hash, um Anfragen schlank zu halten, und wird pausiert, wenn der Browser-Tab verborgen ist.

Sicherheit, Hooks und Portabilität

Öffentliche Endpunkte sind durch einen automatisch eingefügten X-BS-Token-CSRF-Header geschützt. Verwende 'open', wenn du wirklich nicht authentifizierten Zugriff brauchst, etwa für eingehende Webhooks.

Lebenszyklus-Hooks werden vor und nach jedem Schreibvorgang ausgeführt. Definiere sie direkt in db.php oder global über WordPress-Aktionen.

Felder können einen component-Schlüssel für die schema-gesteuerte Formularausgabe über bs_db_form() definieren.

Mit SQLite- oder JSONC-Speicher lebt die gesamte Anwendung in einem Ordner: Code, Logik, Zugriffskontrolle und Daten. Kopiere ihn, um die Anwendung bereitzustellen.

RPC

Manchmal reicht CRUD nicht aus. Du brauchst eigene Serverlogik: eine Aufgabe umschalten, eine Benachrichtigung senden, Statistiken zusammenfassen. Dafür gibt es rpc.php. Definiere eine PHP-Funktion, rufe sie im Frontend mit bs.fn() auf, und Blockstudio kümmert sich um den REST-Endpunkt, die Authentifizierung, den CSRF-Schutz und die Serialisierung von JSON. Das Muster ist von tRPC inspiriert: Prozeduren werden serverseitig definiert und vom Client anhand ihres Namens aufgerufen.

PHP
return [
    'subscribe' => function (array $params): array {
        $email = sanitize_email($params['email']);
        return ['success' => true];
    },
];
JavaScript
const result = await bs.fn('subscribe', { email: 'user@example.com' });

Inline-Skripte (script-inline.js) erkennen den Blocknamen automatisch anhand des data-block-Attributs ihres Script-Tags. Du musst ihn also nicht manuell übergeben. Bei Modul-Skripten übergibst du ihn als drittes Argument.

Zu den Optionen für die Zugriffskontrolle gehören public (mit CSRF), 'open' (ohne Schutz), Berechtigungszeichenfolgen oder Arrays. Unterstützt werden außerdem die HTTP-Methodensteuerung pro Funktion, Lebenszyklus-Hooks und Aufrufe über Blockgrenzen hinweg aus JS und PHP.

Cron

Hintergrundaufgaben werden in einer cron.php-Datei definiert. Lege einen Zeitplan und einen Callback fest, und Blockstudio registriert sie beim Initialisieren bei WordPress Cron. Wird das Plugin deaktiviert, werden alle Aufgaben zuverlässig aus dem Zeitplan entfernt.

PHP
return [
    'cleanup' => [
        'schedule' => 'daily',
        'callback' => function () {
            $db = Db::get('my-theme/app', 'logs');
            // delete old entries
        },
    ],
    'sync' => [
        'schedule' => 'hourly',
        'callback' => function () {
            // pull from external API
        },
    ],
];

Alle integrierten WordPress-Zeitpläne werden unterstützt, ebenso benutzerdefinierte Intervalle über den Filter cron_schedules.

CLI

Ein neuer wp bs-Befehl deckt den gesamten Funktionsumfang von Blockstudio ab: Blöcke, Datenbank, RPC, cron, Einstellungen, Tailwind-Kompilierung, SCSS-Kompilierung, benutzerdefinierte Felder und Asset-Verwaltung.

Shell
wp bs blocks list --components
wp bs db schemas
wp bs db create my-theme/app subs --email=a@b.com
wp bs db list my-theme/app subs --plan=pro --format=json
wp bs rpc call my-theme/app subscribe --email=a@b.com
wp bs cron run my-theme/app cleanup
wp bs tailwind compile --file=template.html
wp bs scss compile --file=style.scss
wp bs fields list
wp bs assets list --type=global
wp bs settings get tailwind/enabled

Alle Befehle unterstützen --format=json für Skripte.

Verbesserungen am Repeater

textMinimized für Objektfelder

Eingeklappte Repeater-Zeilen verarbeiten jetzt Werte von Objektfeldern korrekt. Wenn textMinimized auf ein Linkfeld verwies, wurde bisher [object Object] angezeigt. Jetzt liest Blockstudio je nach Feldtyp automatisch die passende Untereigenschaft aus: title für Links, value für Farben und Verläufe, icon für Icons. Du kannst auch eine explizite Eigenschaft key festlegen, um eine beliebige Untereigenschaft auszulesen.

JSON
{
  "type": "repeater",
  "textMinimized": { "id": "href", "fallback": "Add a link" },
  "attributes": [{ "id": "href", "type": "link" }]
}

RichText und MediaPlaceholder

Beide Vorlagenkomponenten funktionieren jetzt in Repeater-Feldern mit Klammernotation, um die richtige Zeile anzusprechen. So kannst du Überschriften und Absätze direkt bearbeiten und in jeder Repeater-Zeile Medien hochladen.

Twig
{% for item in a.items %}
  <div class="card">
    <MediaPlaceholder attribute="items[{{ loop.index0 }}].image" />
    <RichText tag="h2" attribute="items[{{ loop.index0 }}].heading" />
    <RichText tag="p" attribute="items[{{ loop.index0 }}].content" />
  </div>
{% endfor %}

Benutzerdefinierte Feldbedingungen mit idStructure

Wird ein benutzerdefiniertes Feld mit idStructure verwendet, passen sich die IDs der Bedingungen in der Felddefinition jetzt automatisch an die erweiterten Namen an. Hat deine Gruppe für Schriftgrößen eine Bedingung für enable und erweiterst du sie mit idStructure: "title_font_{id}", verweist die Bedingung nun korrekt auf title_font_enable statt auf das ursprüngliche enable.

Bedingungen auf Referenzebene werden ebenfalls unterstützt. Füge conditions zur Referenz des benutzerdefinierten Felds hinzu, um sie auf alle erweiterten Felder gleichzeitig anzuwenden.

Dynamische Populate-Argumente

Populate-Argumente können jetzt mit der Syntax {attributes.*} auf andere Blockattribute verweisen. Ändert sich das referenzierte Attribut, lädt das Auswahlfeld seine Optionen automatisch neu. Verknüpfe mehrere Auswahlfelder: eines zur Wahl eines Beitragstyps, ein weiteres zum Laden der Beiträge dieses Typs.

JSON
{
  "id": "selected_post",
  "type": "select",
  "populate": {
    "type": "query",
    "query": "posts",
    "arguments": {
      "post_type": "{attributes.post_type}"
    }
  }
}

Ändere post_type zu “page”, und das zweite Auswahlfeld lädt Seiten. Ändere es zu “post”, und es lädt Beiträge. Funktioniert mit jedem Populate-Typ und jedem Attribut.

Composer

Blockstudio funktioniert jetzt auch, wenn es an einem beliebigen Ort unter wp-content/ geladen wird, nicht nur im Plugin-Verzeichnis. Asset-URLs werden über eine BLOCKSTUDIO_URL-Konstante statt über plugins_url() aufgelöst. Dadurch funktionieren Installationen mit gebündeltem Theme sofort:

PHP
require_once __DIR__ . '/vendor/autoload.php';
require_once __DIR__ . '/vendor/blockstudio/blockstudio/blockstudio.php';

Die Laufzeitabhängigkeiten von composer.json wurden bereinigt. Namespaced-Pakete (TailwindPHP, ScssPhp, Minify), die bereits in lib/ enthalten sind, werden nicht länger als Laufzeitabhängigkeiten aufgeführt. Nur php >= 8.2 und plugin-update-checker bleiben übrig.

Alle drei Installationsmethoden (Plugin-ZIP, Plugin über Composer, Theme-Bündelung über Composer) führen zum selben Ergebnis: vollständige Aktivierung von WordPress, Blockregistrierung und Frontend-Ausgabe.

Eine Anleitung zur Einrichtung findest du in der Composer-Dokumentation.

Performance-Profiler

Füge ?blockstudio-perf zu einer beliebigen Seite URL hinzu, und am unteren Rand erscheint ein Debug-Panel mit Renderzeiten pro Block, Phasenaufschlüsselungen und Cache-Trefferraten. Zeitmessdaten werden außerdem als Server-Timing-Header gesendet und sind im Netzwerk-Tab der Browser-DevTools sichtbar.

JSON
{ "dev": { "perf": true } }

Aktiviere die Funktion dauerhaft in den Einstellungen, um jeden Seitenaufruf zu profilieren. Sichtbar ist sie nur für angemeldete Benutzer mit der Berechtigung edit_posts.

Auch selbstschließende Block-Tags werden jetzt im Speicher zwischengespeichert. Wenn derselbe Block mit identischen Attributen mehrmals auf einer Seite vorkommt, überspringen nachfolgende Renderings die gesamte Vorlagen-Pipeline.

Fehlerbehebungen

  • PHP 8.4: Deprecation-Warnungen: Die durch die Übergabe von null an add_submenu_page() verursachten Deprecation-Warnungen für strpos() und str_replace() wurden behoben.

Mehr

  • SCSS-Codefelder: Codefelder unterstützen language: "scss". Die Werte werden sowohl im Editor als auch im Frontend mit ScssPhp kompiliert.
  • Standard-WordPress-Blöcke: Blockstudio-Verzeichnisse können neben Blockstudio-Blöcken auch @wordpress/create-block-Ausgaben enthalten. Sie werden automatisch registriert, ohne dass zusätzlicher Plugin-Code nötig ist.

Wenn du das Full-Stack-Muster in Aktion sehen möchtest, zeigt dir der Leitfaden zu Full-Stack-Blöcken Schritt für Schritt, wie du von Grund auf eine benutzerspezifische Aufgaben-App und ein öffentliches Newsletter-Anmeldeformular erstellst.