Zum Inhalt springen

PHP-Hooks

Nachfolgend findest du eine Liste aller verfügbaren PHP-Hooks, mit denen du Funktionen des Plugins erweitern oder anpassen kannst.

Pfad

Mit diesem Filter kannst du den Pfad zum Blockordner anpassen. Standardmäßig liegt er blockstudio im aktuell aktiven Theme. Alternativ kannst du eine neue Instanz erstellen, um mehrere Quellverzeichnisse zu verwenden.

PHP
add_filter('blockstudio/path', function() {
  $path = get_stylesheet_directory() . '/blocks';
  return $path;
});

Init

global

Diese Aktion wird ausgelöst, nachdem das Plugin alle Blöcke registriert hat.

PHP
add_action('blockstudio/init', function($blocks) {
  // All blocks have been registered
});

instance

Diese Aktion wird ausgelöst, nachdem das Plugin alle Blöcke einer bestimmten Instanz registriert hat. Das Segment $instance ist der Instanzpfad relativ zu wp-content.

PHP
$instance = 'themes/my-theme/client-blocks';
add_action("blockstudio/init/$instance", function() {
  // All blocks of this instance have been registered
});

global/before

Diese Aktion wird ausgelöst, bevor das Plugin alle Blöcke registriert hat.

PHP
add_action('blockstudio/init/before', function() {
  // Before blocks are registered
});

global/before/$instance

Diese Aktion wird ausgelöst, bevor das Plugin alle Blöcke einer bestimmten Instanz registriert hat.

PHP
$instance = 'themes/my-theme/client-blocks';
add_action("blockstudio/init/before/$instance", function() {
  // Before blocks of this instance are registered
});

Blöcke

render

Mit diesem Filter kannst du die Ausgabe eines Blocks vor dem Rendern anpassen.

PHP
add_filter('blockstudio/blocks/render', function($content, $block, $attributes) {
  // Modify the block content
  return $content;
}, 10, 3);

meta

Mit diesem Filter kannst du die Daten der Datei block.json vor ihrer Registrierung anpassen.

PHP
add_filter('blockstudio/blocks/meta', function($meta, $block) {
  if (str_starts_with($block['name'], 'marketing')) {
    $meta['icon'] = 'megaphone';
  }
  return $meta;
}, 10, 2);

Der obige Code ändert das Symbol aller Blöcke, deren Name mit marketing beginnt.

conditions

Mit diesem Filter kannst du benutzerdefinierte Bedingungen hinzufügen, die in Blöcken verwendet werden können. Jedem Bedingungstyp ist ein Wert zugeordnet, den der Editor mit dem value der Bedingung vergleicht. Siehe Benutzerdefinierte Bedingungen.

PHP
add_filter('blockstudio/blocks/conditions', function($conditions) {
  $conditions['myCustomCondition'] = 'expected';
  return $conditions;
});

Attribute

Dieser Filter passt eine Felddefinition an, bevor der Block registriert wird. Die gefilterte Definition steuert das Editor-Steuerelement und die Validierung des Werts beim Rendern. Weitere Informationen findest du unter Filtern.

PHP
add_filter('blockstudio/blocks/attributes', function($attribute, $block) {
  // Modify this field definition before registration.
  return $attribute;
}, 10, 2);

attributes/render

Dieser Filter passt den Wert eines Feldes an, bevor er an das Block-Template übergeben wird. Er wird einmal pro Feld ausgeführt und erhält drei Argumente: $value (den aufgelösten Wert), $key (den Feldschlüssel, wie in $a verwendet) und $block (das Blockdaten-Array, das Templates als $block oder $b erhalten). Registriere ihn mit drei akzeptierten Argumenten. Weitere Informationen findest du unter Filtern.

PHP
add_filter('blockstudio/blocks/attributes/render', function($value, $key, $block) {
  // Modify the value of one field before rendering.
  return $value;
}, 10, 3);

attributes/files/sizes

Ein files-Feld gibt jedes Bild mit einem sizes-Array zurück, das URL, Breite und Höhe von full sowie jeder registrierten Bildgröße enthält, zum Beispiel $image['sizes']['thumbnail'] und $image['sizes']['thumbnail-width']. Jede Größe entspricht einem wp_get_attachment_image_src()-Aufruf pro Bild, daher gelten die zugehörigen Filter weiterhin. Templates, die sizes nie auslesen, können die Liste entfernen oder kürzen.

PHP
add_filter('blockstudio/blocks/attributes/files/sizes', function($sizes, $id, $size) {
  // Keep only two sizes. Return an empty array to skip them, `sizes` is then null.
  return ['full', 'large'];
}, 10, 3);

$sizes ist die Liste der Größennamen, zuerst full (leer, wenn keine Zwischengrößen registriert sind). $id ist die Anhang-ID und $size die für den url-Wert angeforderte Größe. Der Filter ändert das sizes-Array jedes Dateiwerts in der Anfrage. Ohne den Filter bleibt das Array unverändert.

Gib die Größennamen als Zeichenfolgen zurück. Ungültige Einträge werden ignoriert, doppelte Namen nur einmal verarbeitet und bei einem Rückgabewert, der kein Array ist, werden die Größen übersprungen. Die angeforderte url und andere Eigenschaften des Anhangs bleiben unverändert. Dieser Hook wird nicht für ein Feld vom Typ „files“ mit returnFormat: "url" ausgeführt, da dabei keine Größenübersicht erstellt wird.

attributes/validate

Passe Ergebnisse aus expliziten bs_validate_block()-Aufrufen an, zum Beispiel wenn ein benutzerdefinierter Render-Filter gespeicherte Referenzen auflöst. Dadurch wird keine automatische Validierung beim Speichern oder Rendern aktiviert.

PHP
add_filter('blockstudio/blocks/attributes/validate', function($findings, $name, $attrs) {
  return $findings;
}, 10, 3);

Gib eine Liste von Befunden zurück. Der Filter wird nicht aufgerufen, wenn der Block keine Blockstudio-Felder oder passenden Erweiterungen (null) hat.

attributes/schema

Passe das JSON-Schema an, das von bs_block_schema() zurückgegeben wird, zum Beispiel wenn ein benutzerdefinierter Render-Filter gespeicherte Referenzen auflöst.

PHP
add_filter('blockstudio/blocks/attributes/schema', function($schema, $name) {
  return $schema;
}, 10, 2);

Gib das Schema-Array zurück. Der Filter wird nicht aufgerufen, wenn der Block keine Blockstudio-Felder oder passenden Erweiterungen hat (null).

attributes/populate

Mit diesem Filter kannst du den Optionen eines Felds vom Typ checkbox, select oder radio benutzerdefinierte Daten hinzufügen. Weitere Informationen findest du unter Optionen befüllen.

Der Filter erhält ein Argument: ein Array aller benutzerdefinierten Datensätze, sortiert nach dem in "populate": {"type": "custom", "custom": "myCustomOptions"} verwendeten Namen.

PHP
add_filter('blockstudio/blocks/attributes/populate', function($options) {
  $options['myCustomOptions'] = [
    ['value' => '1', 'label' => 'Option 1'],
    ['value' => '2', 'label' => 'Option 2'],
  ];
  return $options;
});

components/use_block_props/render

Mit diesem Filter kannst du die Ausgabe des Inhalts von useBlockProps anpassen.

Alle Komponentenfilter (use_block_props, inner_blocks und rich_text) erhalten den Block als letztes Argument. $block ist die für den gerenderten Block registrierte WP_Block_Type, daher ist $block->name der Blockname, zum Beispiel acme/hero.

$props ist eine Zeichenfolge mit HTML-Attributen, kein Array. Im Frontend ist sie das Ergebnis von get_block_wrapper_attributes(), zum Beispiel class="wp-block-acme-hero my-class". Im Editor ist sie das class-Attribut des Elements. Gib eine Zeichenfolge zurück. Im Editor wird nur das class-Attribut der zurückgegebenen Zeichenfolge angewendet.

PHP
add_filter('blockstudio/blocks/components/use_block_props/render', function($props, $block) {
  if ($block->name !== 'acme/hero') {
    return $props;
  }

  return str_replace('class="', 'class="my-custom-class ', $props);
}, 10, 2);

components/inner_blocks/render

Mit diesem Filter kannst du die Ausgabe des Inhalts von <InnerBlocks /> anpassen.

PHP
add_filter('blockstudio/blocks/components/inner_blocks/render', function($content, $block) {
  return '<div class="inner-wrapper">' . $content . '</div>';
}, 10, 2);

components/inner_blocks/frontend/wrap

Mit diesem Filter kannst du den Wrapper von <InnerBlocks /> im Frontend entfernen.

PHP
add_filter('blockstudio/blocks/components/inner_blocks/frontend/wrap', function($wrap, $block) {
  return false; // Remove wrapper
}, 10, 2);

components/rich_text/render

Mit diesem Filter kannst du die Ausgabe des Inhalts von <RichText /> anpassen. Er erhält den Wert des Attributs und den Block.

PHP
add_filter('blockstudio/blocks/components/rich_text/render', function($content, $block) {
  return wp_kses_post($content);
}, 10, 2);

Block-Tags

blockstudio/block_tags/builders

Dieser Filter registriert Builder für Block-Arrays, die von Block-Tags und benutzerdefinierten Blöcken verwendet werden, die über blockstudio/parser/element_mapping ausgewählt wurden. Jeder Builder erhält geparste Attribute und unbearbeiteten inneren Inhalt.

PHP
add_filter('blockstudio/block_tags/builders', function($builders, $parser) {
  $builders['theme/paragraph'] = function(array $attributes, string $inner) {
    $attributes['content'] = trim($inner);

    return [
      'blockName' => 'theme/paragraph',
      'attrs' => [
        'blockstudio' => [
          'attributes' => $attributes,
        ],
      ],
      'innerBlocks' => [],
      'innerHTML' => '',
      'innerContent' => [],
    ];
  };

  return $builders;
}, 10, 2);

Die kompatiblen Filter blockstudio/block_tags/renderers und blockstudio/parser/renderers werden nach diesem Hook ausgeführt und können denselben Blocknamen überschreiben.

blockstudio/block_tags/tag_aliases

Mit diesem Filter kannst du benutzerdefinierte Tags mit Bindestrichen registrieren, die vor dem Fallback auf rohes HTML zu echten Blocknamen aufgelöst werden. So kann ein Theme eine kompakte, projektspezifische Tag-Syntax anbieten und trotzdem standardmäßige Blockstudio- oder Core-Blöcke rendern.

PHP
add_filter('blockstudio/block_tags/tag_aliases', function($aliases) {
  $aliases['theme-button'] = 'bsui/button';
  $aliases['theme-card'] = 'theme/card';

  return $aliases;
});
HTML
<theme-button href="/download" label="Download" />
<theme-card title="Fast authoring">
  <p>Children are parsed as nested blocks.</p>
</theme-card>

blockstudio/block_tags/prefixes

Mit diesem Filter kannst du Präfix-Kurzformen einem oder mehreren Block-Namensräumen zuordnen. Jeder Schlüssel ist ein kleingeschriebenes Präfix ohne Bindestriche. Jeder Wert kann eine Namensraumzeichenfolge oder eine geordnete Liste von Namensräumen sein.

PHP
add_filter('blockstudio/block_tags/prefixes', function($prefixes) {
  $prefixes['theme'] = ['theme-components', 'bsui'];

  return $prefixes;
});
HTML
<theme-card title="Homepage" />
<theme-button label="Get started" />
<theme-ui-feature-matrix />

<theme-card> wird zu theme-components/card aufgelöst. <theme-button> versucht zuerst theme-components/button und greift dann auf bsui/button zurück. Explizite Einträge für blockstudio/block_tags/tag_aliases haben für dasselbe Tag Vorrang. Nicht aufgelöste Tags mit Präfix bleiben unverändert.

Präfixe lassen sich kombinieren: Wird ein Tag mit Präfix nicht direkt aufgelöst und ist sein Slug selbst ein registriertes Präfix-Tag, wird die Auflösung rekursiv fortgesetzt. Mit theme => ['theme-components'] und ui => ['bsui'] fällt <theme-ui-input> auf das Präfix ui zurück und wird zu bsui/input aufgelöst. Registrierte Präfix- und Alias-Tags werden auch in der Ausgabe von Block-Templates gerendert, nicht nur im Seiteninhalt.

Einstellungen

path

Mit diesem Filter kannst du den Pfad der Datei blockstudio.json anpassen. Standardmäßig befindet sie sich unter blockstudio.json im aktuell aktiven Theme.

PHP
add_filter('blockstudio/settings/path', function() {
  return get_stylesheet_directory() . '/config/blockstudio.json';
});

users/ids

Mit diesem Filter kannst du den Editor für bestimmte Benutzer-IDs aktivieren.

PHP
add_filter('blockstudio/settings/users/ids', function() {
  return [1];
});

users/roles

Mit diesem Filter kannst du den Editor für bestimmte Benutzerrollen aktivieren.

PHP
add_filter('blockstudio/settings/users/roles', function() {
  return ['administrator', 'editor'];
});

assets/enqueue

Mit diesem Filter kannst du das Einbinden von Assets im Frontend und im Editor aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/assets/enqueue', function() {
  return false;
});

assets/reset/enabled

Mit diesem Filter kannst du das Entfernen der Core-Blockstile von WordPress und das Zurücksetzen des Editor-Utility-Layouts aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/assets/reset/enabled', function() {
  return true;
});

assets/reset/full_width

Mit diesem Filter kannst du festlegen, welche Beitragstypen die Bearbeitung in voller Breite verwenden.

PHP
add_filter('blockstudio/settings/assets/reset/full_width', function() {
  return ['page'];
});

assets/minify/css

Mit diesem Filter kannst du die Minimierung von CSS aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/assets/minify/css', function() {
  return true;
});

assets/minify/js

Mit diesem Filter kannst du die Minimierung von JS aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/assets/minify/js', function() {
  return true;
});

assets/process/scss

Mit diesem Filter kannst du die Verarbeitung von SCSS in .css-Dateien aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/assets/process/scss', function() {
  return true;
});

assets/process/scss_files

Mit diesem Filter kannst du die Verarbeitung von .scss-Dateien zu CSS aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/assets/process/scss_files', function() {
  return true;
});

assets/output

Mit diesem Filter kannst du festlegen, wo kompilierte Block-Assets gespeichert werden.

PHP
add_filter('blockstudio/settings/assets/output', function() {
  return 'cache';
});

assets/inline_limit

Mit diesem Filter kannst du steuern, wie viele Bytes externer CSS-Blöcke pro Seite eingebunden werden.

PHP
add_filter('blockstudio/settings/assets/inline_limit', function() {
  return 40000;
});

cache/enabled

Mit diesem Filter kannst du alle dateibasierten Laufzeit- und Editor-Asset-Caches von Blockstudio aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/cache/enabled', function() {
  return false;
});

cache/path

Mit diesem Filter kannst du das Verzeichnis des dateibasierten Caches von Blockstudio ändern.

PHP
add_filter('blockstudio/settings/cache/path', function() {
  return 'cache/blockstudio';
});

cache/namespace_grace

Mit diesem Filter kannst du festlegen, wie lange ein stillgelegter Cache-Namensraum aufbewahrt wird, bevor er bereinigt wird.

PHP
add_filter('blockstudio/settings/cache/namespace_grace', function() {
  return 777600;
});

githooks/commit

Dieser Filter gibt an, ob der von Blockstudio verwaltete PHPStan-Commit-Hook aktiviert ist.

PHP
add_filter('blockstudio/settings/githooks/commit', function() {
  return true;
});

content/enabled

Mit diesem Filter kannst du Content Sync aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/content/enabled', function() {
  return true;
});

content/id

Mit diesem Filter kannst du den Namensraum für die Content-Sync-Zuordnung festlegen.

PHP
add_filter('blockstudio/settings/content/id', function() {
  return 'docs';
});

content/path

Mit diesem Filter kannst du das Dateiverzeichnis für Content Sync festlegen.

PHP
add_filter('blockstudio/settings/content/path', function() {
  return 'content';
});

content/include_page_sync_managed

Mit diesem Filter kannst du festlegen, ob von Page Sync verwaltete Beiträge ein- oder ausgeschlossen werden.

PHP
add_filter('blockstudio/settings/content/include_page_sync_managed', function() {
  return false;
});

content/authors

Mit diesem Filter kannst du die Autorenverwaltung für Content Sync konfigurieren.

PHP
add_filter('blockstudio/settings/content/authors', function() {
  return 'ignore';
});

content/post_types

Mit diesem Filter kannst du die Zulassungsliste für Beitragstypen in Content Sync konfigurieren.

PHP
add_filter('blockstudio/settings/content/post_types', function() {
  return ['team_member'];
});

content/taxonomies

Mit diesem Filter kannst du die Zulassungsliste für Taxonomien in Content Sync konfigurieren.

PHP
add_filter('blockstudio/settings/content/taxonomies', function() {
  return ['category', 'post_tag'];
});

content/media

Mit diesem Filter kannst du die Medienverwaltung für Content Sync konfigurieren.

PHP
add_filter('blockstudio/settings/content/media', function() {
  return 'manifest';
});

tailwind/enabled

Mit diesem Filter kannst du Tailwind aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/tailwind/enabled', function() {
  return true;
});

tailwind/config

Mit diesem Filter kannst du eine benutzerdefinierte Tailwind CSS-Konfiguration hinzufügen.

PHP
add_filter('blockstudio/settings/tailwind/config', function() {
  return '@theme { --color-primary: pink; }';
});

tailwind/output

Mit diesem Filter kannst du eine Inline- oder verknüpfte Tailwind CSS-Ausgabe auswählen.

PHP
add_filter('blockstudio/settings/tailwind/output', function() {
  return 'link';
});

ui/enabled

Mit diesem Filter kannst du die mitgelieferten Komponenten von UI aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/ui/enabled', function() {
  return true;
});

editor/format_on_save

Mit diesem Filter kannst du die Formatierung des Codes beim Speichern aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/editor/format_on_save', function() {
  return true;
});

editor/assets

Mit diesem Filter kannst du zusätzliche Assets im Editor einbinden.

PHP
add_filter('blockstudio/settings/editor/assets', function() {
  return ['my-stylesheet', 'another-stylesheet'];
});

editor/markup

Mit diesem Filter kannst du am Ende des Editors zusätzliches Markup hinzufügen.

PHP
add_filter('blockstudio/settings/editor/markup', function() {
  return '<style>body { background: black; }</style>';
});

block_editor/disable_loading

Mit diesem Filter kannst du das Laden von Blöcken im Block Editor deaktivieren.

PHP
add_filter('blockstudio/settings/block_editor/disable_loading', function() {
  return true;
});

block_editor/enhance

Mit diesem Filter kannst du Verbesserungen für den Editor von Blockstudio aktivieren, etwa übersichtlichere Fokusstile und Umrisse bei Hover und Auswahl.

PHP
add_filter('blockstudio/settings/block_editor/enhance', function() {
  return true;
});

block_editor/css_classes

Mit diesem Filter kannst du Stylesheets hinzufügen, deren Klassen im Klassenfeld zur Auswahl stehen sollen.

PHP
add_filter('blockstudio/settings/block_editor/css_classes', function() {
  return ['my-stylesheet', 'another-stylesheet'];
});

block_editor/css_variables

Mit diesem Filter kannst du Stylesheets hinzufügen, deren CSS-Variablen im Codefeld zur automatischen Vervollständigung verfügbar sein sollen.

PHP
add_filter('blockstudio/settings/block_editor/css_variables', function() {
  return ['my-stylesheet', 'another-stylesheet'];
});

block_editor/blocks/allow

Mit diesem Filter kannst du festlegen, welche Blocknamen im Inserter zulässig sind.

PHP
add_filter('blockstudio/settings/block_editor/blocks/allow', function() {
  return ['core/*', 'acf/*', 'my-theme/*'];
});

block_editor/blocks/deny

Mit diesem Filter kannst du Blocknamen aus dem Inserter entfernen.

PHP
add_filter('blockstudio/settings/block_editor/blocks/deny', function() {
  return ['core/embed', 'core/freeform'];
});

block_editor/blocks/directory

Mit diesem Filter kannst du die Assets des WordPress-Blockverzeichnisses im Editor aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/block_editor/blocks/directory', function() {
  return false;
});

block_editor/blocks/categories/allow

Mit diesem Filter kannst du festlegen, welche Slugs von Blockkategorien verfügbar bleiben.

PHP
add_filter('blockstudio/settings/block_editor/blocks/categories/allow', function() {
  return ['text', 'media', 'design'];
});

block_editor/blocks/categories/deny

Mit diesem Filter kannst du Slugs von Blockkategorien aus dem Inserter entfernen.

PHP
add_filter('blockstudio/settings/block_editor/blocks/categories/deny', function() {
  return ['embed'];
});

block_editor/blocks/categories/rename

Mit diesem Filter kannst du Bezeichnungen von Blockkategorien anhand ihres Slugs umbenennen.

PHP
add_filter('blockstudio/settings/block_editor/blocks/categories/rename', function() {
  return [
    'text' => 'Writing',
    'design' => 'Layout'
  ];
});

block_editor/blocks/categories/order

Mit diesem Filter kannst du die Reihenfolge der Slugs von Blockkategorien im Inserter festlegen.

PHP
add_filter('blockstudio/settings/block_editor/blocks/categories/order', function() {
  return ['my-theme', 'text', 'media'];
});

block_editor/blocks/styles/deny

Mit diesem Filter kannst du registrierte Blockstile von PHP anhand des Blocknamens abmelden.

PHP
add_filter('blockstudio/settings/block_editor/blocks/styles/deny', function() {
  return [
    'my-theme/card' => ['outline'],
    'my-theme/media' => ['framed']
  ];
});

block_editor/blocks/legacy_widgets/hide

Mit diesem Filter kannst du zusätzliche ältere Widgets im Block für ältere Widgets ausblenden.

PHP
add_filter('blockstudio/settings/block_editor/blocks/legacy_widgets/hide', function() {
  return ['archives', 'calendar'];
});

block_editor/patterns/core

Mit diesem Filter kannst du die Core-Blockmuster von WordPress aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/block_editor/patterns/core', function() {
  return false;
});

block_editor/patterns/remote

Mit diesem Filter kannst du Remote-Muster aus dem Musterverzeichnis von WordPress aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/block_editor/patterns/remote', function() {
  return false;
});

block_editor/patterns/theme

Mit diesem Filter kannst du vom Theme bereitgestellte Blockmuster aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/block_editor/patterns/theme', function() {
  return false;
});

block_editor/patterns/blockstudio

Mit diesem Filter kannst du dateibasierte Muster von Blockstudio aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/block_editor/patterns/blockstudio', function() {
  return false;
});

block_editor/patterns/categories/allow

Mit diesem Filter kannst du festlegen, welche Slugs von Musterkategorien verfügbar bleiben.

PHP
add_filter('blockstudio/settings/block_editor/patterns/categories/allow', function() {
  return ['featured', 'buttons', 'columns'];
});

block_editor/patterns/categories/deny

Mit diesem Filter kannst du Slugs von Musterkategorien aus dem Muster-Inserter entfernen.

PHP
add_filter('blockstudio/settings/block_editor/patterns/categories/deny', function() {
  return ['gallery'];
});

block_editor/patterns/categories/rename

Mit diesem Filter kannst du Bezeichnungen von Musterkategorien anhand ihres Slugs umbenennen.

PHP
add_filter('blockstudio/settings/block_editor/patterns/categories/rename', function() {
  return [
    'featured' => 'Featured Layouts'
  ];
});

block_editor/patterns/categories/order

Mit diesem Filter kannst du die Reihenfolge der Slugs von Musterkategorien im Inserter festlegen.

PHP
add_filter('blockstudio/settings/block_editor/patterns/categories/order', function() {
  return ['featured', 'buttons'];
});

block_editor/media/openverse

Mit diesem Filter kannst du die Medienkategorie Openverse im Medien-Inserter des Block-Editors aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/block_editor/media/openverse', function() {
  return false;
});

block_editor/media/image_sizes/allow

Mit diesem Filter kannst du festlegen, welche Bildgrößennamen in den Medieneinstellungen des Editors verfügbar bleiben.

PHP
add_filter('blockstudio/settings/block_editor/media/image_sizes/allow', function() {
  return ['thumbnail', 'large'];
});

block_editor/media/image_sizes/deny

Mit diesem Filter kannst du Bildgrößennamen aus den Medieneinstellungen des Editors entfernen.

PHP
add_filter('blockstudio/settings/block_editor/media/image_sizes/deny', function() {
  return ['medium_large'];
});

ai/enable_context_generation

Mit diesem Filter kannst du die Erstellung von Kontextdateien für die Integration von LLM-Tools aktivieren oder deaktivieren. Ist sie aktiviert, führt die Kontextdatei aktuelle Blockdaten, Blockstudio-Einstellungen der aktuellen Installation, alle relevanten Schemas und die Dokumentation zu Blockstudio in einer Quelle für KI-Entwicklungstools zusammen.

PHP
add_filter('blockstudio/settings/ai/enable_context_generation', function() {
  return true;
});

block_tags/enabled

Mit diesem Filter kannst du das Rendern von Block-Tags auf Seitenebene aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/block_tags/enabled', function() {
  return true;
});

block_tags/prefixes

Mit diesem Filter kannst du Kurzformen für Präfixe und Namensräume von Block-Tags registrieren.

PHP
add_filter('blockstudio/settings/block_tags/prefixes', function() {
  return [
    'theme' => ['theme-components', 'bsui']
  ];
});

dev/grab/enabled

Mit diesem Filter kannst du den Element-Grabber aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/dev/grab/enabled', function() {
  return false;
});

dev/perf

Mit diesem Filter kannst du den Performance-Profiler aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/dev/perf', function() {
  return false;
});

dev/canvas/enabled

Mit diesem Filter kannst du Canvas aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/settings/dev/canvas/enabled', function() {
  return false;
});

dev/canvas/admin_bar

Mit diesem Filter kannst du die Admin-Leiste von WordPress auf Canvas ein- oder ausblenden.

PHP
add_filter('blockstudio/settings/dev/canvas/admin_bar', function() {
  return true;
});

WPML

blockstudio/wpml/config/label

Filtert die Beschriftung jedes Schlüssels, den wp bs wpml config schreibt. Siehe Beschriftungen ändern für das Kontext-Array.

PHP
add_filter('blockstudio/wpml/config/label', function($label, $context) {
  return str_replace(' (optional)', '', $label);
}, 10, 2);

Canvas

blockstudio/canvas/inventory

Dieser Filter passt den Bestand an, den Canvas für eine Auswahl meldet. Der Callback erhält das DTO des Bestands, die ursprüngliche Auswahl und die Optionen, mit denen er aufgerufen wurde.

PHP
add_filter('blockstudio/canvas/inventory', function(array $result, array $selection, array $options) {
  return $result;
}, 10, 3);

blockstudio/canvas/documents

Dieser Filter passt die gerenderten Dokumente an, die Canvas zurückgibt, und erhält dieselben drei Argumente wie der Bestandsfilter.

blockstudio/canvas/item_loaded

Diese Aktion wird beim Laden jedes Bestandsdatensatzes einmal ausgelöst. Sie erhält den Bestandstyp, die kanonische Datensatz-ID und den normalisierten Datensatz.

blockstudio/canvas/source_compiled

Diese Aktion wird ausgelöst, nachdem eine Quelldatei für Canvas kompiliert wurde. Sie erhält den ausgewählten Quellpfad und den kanonischen Quelldatensatz.

Mitgeliefertes UI

blockstudio/ui/directories

Dieser Filter passt die Verzeichnisse an, die nach mitgelieferten UI-Komponenten durchsucht werden.

blockstudio/ui/inventory

Dieser Filter passt das öffentliche UI-Familieninventar an.

blockstudio/ui/examples

Dieser Filter passt die UI-Beispieleinträge an und erhält die Beispiele sowie das öffentliche UI-Inventar, aus dem sie abgeleitet wurden.

Topologie

blockstudio/blocks/topology_refreshed

Diese Aktion wird ausgelöst, nachdem die Blocktopologie neu aufgebaut wurde.

blockstudio/pages/topology_refreshed

Diese Aktion wird ausgelöst, nachdem die Seitentopologie neu aufgebaut wurde.

blockstudio/pages/layout_error

Diese Aktion wird ausgelöst, wenn ein Seitenlayout nicht gerendert werden kann, statt den Fehler stillschweigend zu übergehen.

Laufzeit

blockstudio/runtime/initialized

Diese Aktion wird einmal ausgelöst, sobald die Laufzeit ihre Konfiguration aufgelöst hat.

blockstudio/runtime/changed

Diese Aktion wird ausgelöst, wenn sich die aufgelöste Laufzeitidentität ändert. Dadurch ändern sich Cache-Namespaces und der Zustand des statischen Prerenderings.

blockstudio/performance/default_config

Dieser Filter passt die Performance-Standardwerte an, bevor die projektspezifischen blockstudio.json-Werte hinzugefügt werden.

Inhalte

blockstudio/content/orphan_action

Dieser Filter legt fest, was die Inhaltssynchronisierung mit einem Eintrag macht, der keine Quelle mehr hat.

Bootstrap

blockstudio/url

Dieser Filter ändert die öffentliche URL, die für den Editor und die Admin-Assets von Blockstudio verwendet wird. Composer-Integrationen müssen ihn registrieren, bevor sie die Autoload-Datei von Blockstudio laden. Das zweite Argument ist das physische Paketverzeichnis.

PHP
add_filter(
  'blockstudio/url',
  function(string $url, string $directory) {
    return get_stylesheet_directory_uri() . '/vendor/blockstudio/blockstudio/';
  },
  10,
  2
);

Laufzeit-Cache

blockstudio/cache/dir

Dieser Filter erhält das aufgelöste Cache-Stammverzeichnis, bevor ein Laufzeit-, Editor-Assets- oder anderer Cache-Bereich angehängt wird.

PHP
add_filter('blockstudio/cache/dir', function(string $directory) {
  return WP_CONTENT_DIR . '/cache/blockstudio';
});

blockstudio/cache/context

Dieser Filter fügt Cache-Identitäten eine serialisierbare Laufzeitvariante hinzu. Verwende ihn, wenn dieselbe Erkennungsquelle verschiedene logische Inventare auswählen kann.

PHP
add_filter('blockstudio/cache/context', function($context, string $scope) {
  return [
    'preview' => get_query_var('preview_id'),
    'site' => get_current_blog_id(),
  ];
}, 10, 2);

blockstudio/cache/site_key

Dieser Filter ändert die Verzeichnisidentität des Netzwerks oder Blogs für Hosts mit einer eigenen Mandantengrenze. Der zurückgegebene Wert wird vor der Verwendung bereinigt.

PHP
add_filter(
  'blockstudio/cache/site_key',
  function(string $key, int $networkId, int $blogId) {
    return sprintf('tenant-%d-%d', $networkId, $blogId);
  },
  10,
  3
);

blockstudio/runtime/identity

Dieser Filter ergänzt Hostinformationen, die sich auf jedes Objekt in einem Laufzeitbereich auswirken. Quell-Fingerprints für einzelne Elemente sollten stattdessen vom zuständigen API als explizite Abhängigkeiten übergeben werden.

PHP
add_filter(
  'blockstudio/runtime/identity',
  function(array $identity, string $scope) {
    $identity['deployment'] = getenv('RELEASE_SHA') ?: 'local';
    return $identity;
  },
  10,
  2
);

blockstudio/cache/watch_debounce

Filtert, wie viele Sekunden ein validierter Dateiüberwachungs-Snapshot ohne erneuten Dateisystem-Stat-Durchlauf wiederverwendet werden kann. Der Standardwert ist 0 in lokalen Umgebungen und Entwicklungsumgebungen und andernorts 20.

PHP
add_filter('blockstudio/cache/watch_debounce', function() {
  return 30;
});

blockstudio/cache/build_wait_budget

Filtert, wie lange eine Anfrage in Millisekunden darauf wartet, dass ein parallel laufender Builder den Laufzeit-Cache oder eine Aktualisierung der Auswahlwerte veröffentlicht, bevor sie mit einer eingeschränkten Antwort fortfährt. Der Standardwert ist 5000 für strukturelle Neuaufbauten und 4000 für Aktualisierungen der Auswahlwerte.

PHP
add_filter('blockstudio/cache/build_wait_budget', function() {
  return 2000;
});

blockstudio/cache/populate_debounce

Filtert, wie viele Sekunden eine Folge von Inhalts-, Begriffs-, Benutzer- oder Meta-Schreibvorgängen zu einer Aktualisierung der Auswahlwerte zusammengefasst wird. Der erste Schreibvorgang nach einer ruhigen Phase löst sofort eine Aktualisierung aus; der letzte Schreibvorgang einer Folge wird nach Ablauf des Zeitfensters berücksichtigt. Der Standardwert ist 30. Gib 0 zurück, um bei jedem Schreibvorgang zu aktualisieren.

PHP
add_filter('blockstudio/cache/populate_debounce', function() {
  return 120;
});

blockstudio/cache/populate_ignored_meta_keys

Filtert Meta-Schlüssel, deren Schreibvorgänge gespeicherte Auswahlmöglichkeiten nie aktualisieren. Standardmäßig sind dies die Schlüssel, die WordPress für Bearbeitungs- und Anmeldeprotokolle schreibt: _edit_lock, das vom Editor und Heartbeat aktualisiert wird, solange ein Beitrag geöffnet ist, _edit_last, das bei einem Speichern des Beitrags geschrieben wird, das ohnehin eine Aktualisierung auslöst, und session_tokens, das bei der An- und Abmeldung geschrieben wird. Füge Schlüssel hinzu, die sich häufig ändern, aber eine Abfrage zum Befüllen nie beeinflussen.

PHP
add_filter('blockstudio/cache/populate_ignored_meta_keys', function(array $keys) {
  $keys[] = '_my_view_counter';
  return $keys;
});

blockstudio/cache/max_files_per_scope

Filtert, wie viele veröffentlichte Nutzdaten jedes Laufzeit-Cache-Segment speichert.

PHP
add_filter('blockstudio/cache/max_files_per_scope', function($maximum, $scope) {
  return $scope === 'runtime' ? 50 : $maximum;
}, 10, 2);

blockstudio/cache/compress

Filtert, ob eine Cache-Nutzlast komprimierte serialisierte Daten statt eines einfachen PHP-Arrays verwendet. Standardmäßig wird das einfache Format nur für Nutzlasten bis zu 1 MiB verwendet und nur, wenn der aktive gemeinsame OPcache-Speicher das Ziel zwischenspeichern kann. Andere Prozesse, ausgeschlossene Dateien und größere Nutzlasten verwenden Komprimierung.

PHP
add_filter('blockstudio/cache/compress', function($compress, $scope) {
  return $scope === 'runtime' ? false : $compress;
}, 10, 2);

Wenn du false zurückgibst, wird auch die Größenbegrenzung aufgehoben. Das kann helfen, wenn WP-CLI ohne opcache.enable_cli Dateien für Web-Worker mit aktiviertem OPcache vorab lädt; allerdings muss dann jeder Leser ohne OPcache das erzeugte Array parsen. Verwende für große gemeinsam genutzte Nutzlasten weiterhin Komprimierung, sofern die zusätzlichen Speicherkosten nicht akzeptabel sind. Unter Cache-Nutzlastformate findest du die standardmäßigen Schutzvorkehrungen.

blockstudio/cache/protected_paths

Beim Bereinigen des Cache-Pfads dürfen diese Pfade niemals entfernt werden. Blockstudio fügt alle Dateien hinzu, auf die die installierte Map für frühe Auslieferung verweist.

PHP
add_filter('blockstudio/cache/protected_paths', function(array $paths, string $scope, string $directory) {
  if ('static-prerender' === $scope) {
    $paths[] = $directory . '/pinned.html';
  }
  return $paths;
}, 10, 3);

blockstudio/cache/outcome

Diese Aktion meldet einen gemeinsam genutzten Cache-Bereich und ein Ergebnis wie hit, build, miss-stale, stale-last-good oder write-failure.

PHP
add_action('blockstudio/cache/outcome', function(string $scope, string $reason) {
  my_metrics()->increment("blockstudio.cache.{$scope}.{$reason}");
}, 10, 2);

blockstudio/static_prerender/request_bypass

Dieser Filter erhält die abschließende Entscheidung zur anonymen Sicherheit sowie Server- und Cookie-Eingaben. Wenn du true zurückgibst, werden statische Auslieferung und Generierung immer umgangen.

PHP
add_filter(
  'blockstudio/static_prerender/request_bypass',
  function(bool $bypass, array $server, array $cookies) {
    return $bypass || isset($cookies['commerce_session']);
  },
  10,
  3
);

blockstudio/static_prerender/public_urls

Dieser Filter liefert das vollständige öffentliche URL-Inventar für den geplanten Vorwärmer und die expliziten Graph-Werkzeuge oder passt es an.

PHP
add_filter('blockstudio/static_prerender/public_urls', function(array $urls) {
  $urls[] = home_url('/custom-route/');
  return array_values(array_unique($urls));
});

Was der Filter zurückgibt, ist nicht das endgültige Inventar. Das Ergebnis durchläuft eine Cachebarkeitprüfung, die alle Einträge verwirft, die einem konfigurierten dynamischen Pfad entsprechen oder standardmäßig umgangen werden: /wp-admin, /wp-json, /wp-login.php, /xmlrpc.php, alle Pfade mit /feed/ sowie Suchergebnisse unterhalb des Suchstamms am Startpfad der Website (standardmäßig /search/). Ein von dir hinzugefügtes URL kann daher ohne Warnung verworfen werden. Fehlt eine erwartete Route im erstellten Inventar, prüfe sie anhand dieser Regeln, bevor du davon ausgehst, dass der Filter nicht ausgeführt wurde.

blockstudio/static_prerender/render_internal

Dieser Filter implementiert den optionalen In-Process-Batch-Transport. Gib ein normalisiertes Ergebnis-Array zurück oder lass den Wert unverändert, damit der Renderer seinen konfigurierten HTTP-Fallback verwendet. Das Ergebnis enthält html und optional status, dependencies, virtualHashes und headers; die in performance.staticPrerender.replayHeaders genannten Header werden mit dem Dokument gespeichert.

PHP
add_filter(
  'blockstudio/static_prerender/render_internal',
  function($result, string $url, array $options) {
    return my_static_renderer()->render($url, $options);
  },
  10,
  3
);

blockstudio/static_prerender/cacheable_html

Dieser Filter trifft die endgültige Entscheidung, nachdem Blockstudio geprüft hat, ob die Ausgabe ein vollständiges HTML-Dokument ohne No-Cache-Marker ist und der ermittelte Antwortstatus erfolgreich war. Das dritte Argument ist der ermittelte Status oder null, wenn kein Status angegeben wurde.

PHP
add_filter('blockstudio/static_prerender/cacheable_html', function(bool $cacheable, string $html, ?int $status) {
  return $cacheable && !str_contains($html, 'data-personalized');
}, 10, 3);

blockstudio/static_prerender/outcome

Diese Aktion meldet Ergebnisse des statischen Prerenderings, darunter Treffer, Fehlschläge, Schreibvorgänge, Graph-Schreibvorgänge, veraltete Einträge und Fehler.

PHP
add_action('blockstudio/static_prerender/outcome', function(string $reason) {
  my_metrics()->increment("blockstudio.prerender.{$reason}");
});

blockstudio/tailwind/cache_max_files

Filtert die maximale Anzahl kompilierter Tailwind CSS-Einträge. Der Standardwert ist 1000.

PHP
add_filter('blockstudio/tailwind/cache_max_files', function() {
  return 1500;
});

blockstudio/tailwind/cache_max_age

Filtert das Höchstalter kompilierter Tailwind CSS-Einträge in Sekunden. Der Standardwert beträgt 30 Tage, das Mindestalter eine Stunde.

PHP
add_filter('blockstudio/tailwind/cache_max_age', function() {
  return 14 * DAY_IN_SECONDS;
});

Admin

aktiviert

Mit diesem Filter kannst du die Blockstudio-Adminseite unter Werkzeuge > Blockstudio aktivieren oder deaktivieren.

PHP
add_filter('blockstudio/admin/enabled', function() {
  return false;
});

Assets

editor/canvas/body_class

Wenn das Asset-Reset aktiviert ist, passt dieser Filter die bereinigten Frontend-Body-Klassen an, die in die Blockeditor-Leinwand übernommen werden.

PHP
add_filter('blockstudio/editor/canvas/body_class', function(array $classes) {
  return array_values(array_diff($classes, ['logged-in']));
});

aktivieren

Mit diesem Filter kannst du die Verarbeitung und das Einbinden eines bestimmten Asset-Typs deaktivieren.

PHP
add_filter('blockstudio/assets/enable', function($enable, $type, $block) {
  if ($type === 'css' && $block['name'] === 'my/block') {
    return false;
  }
  return $enable;
}, 10, 3);

deaktivieren

Mit diesem Filter kannst du bestimmte Assets anhand ihrer ID deaktivieren. Assets, deren ID im zurückgegebenen Array enthalten ist, werden im Frontend nicht gerendert.

PHP
add_filter('blockstudio/assets/disable', function($disabled) {
  $disabled[] = 'my-block-style';
  return $disabled;
});

process/scss/import_paths

Mit diesem Filter kannst du der @import-Anweisung des SCSS-Compilers weitere Pfade hinzufügen.

PHP
add_filter('blockstudio/assets/process/scss/import_paths', function($paths) {
  $paths[] = get_stylesheet_directory() . '/scss';
  return $paths;
});

process/scss/prelude

Mit diesem Filter kannst du vor der Kompilierung jeder SCSS-Datei gemeinsam genutzten Sass-Code einfügen.

PHP
add_filter('blockstudio/assets/process/scss/prelude', function($prelude, $path, $scss) {
  return '@import "functions";' . "\n"
    . '@import "variables";' . "\n"
    . '@import "mixins";';
}, 10, 3);

process/css/content

Mit diesem Filter kannst du den Inhalt der CSS-Datei vor der Kompilierung anpassen.

PHP
add_filter('blockstudio/assets/process/css/content', function($content, $block) {
  return str_replace('old-class', 'new-class', $content);
}, 10, 2);

process/js/content

Mit diesem Filter kannst du den Inhalt der JS-Datei vor der Kompilierung anpassen.

PHP
add_filter('blockstudio/assets/process/js/content', function($content, $block) {
  return $content;
}, 10, 2);

Puffer

aktiviert

Blockstudio puffert die Frontend-Antwort, damit Block-Style- und Script-Tags aus dem Body in den Head und Footer verschoben werden können und Tailwind das vollständige Dokument durchsuchen kann. Beim Puffern wird das gesamte Dokument bei jeder Frontend-Anfrage gespeichert und durchsucht. Eine Website, die keine Block-Assets von Blockstudio rendert und Tailwind nicht verwendet, kann false zurückgeben, um beides zu überspringen.

PHP
add_filter('blockstudio/buffer/enabled', '__return_false');

Im Adminbereich und in der Vorschau des Customizers ist das Puffern ebenfalls deaktiviert. Rufe bs_is_buffering() ab wp_enqueue_scripts oder später auf, um herauszufinden, ob die aktuelle Antwort gepuffert wird. Vor der Entscheidung bei template_redirect gibt die Funktion false zurück.

Ausgabe

Dieser Filter erhält das vollständig gepufferte HTML-Dokument, bevor es gesendet wird. Das Verschieben der Assets von Blockstudio läuft mit Priorität 1000000 und die Tailwind-Kompilierung mit 999999. Wähle daher eine frühere Priorität, um das Dokument davor zu sehen, oder eine spätere, um die endgültige Ausgabe zu sehen.

PHP
add_filter('blockstudio/buffer/output', function(string $html) {
  return $html;
}, 2000000);

Rendering

Abhängigkeiten

Dieser Filter meldet bei jedem Rendern eines Blocks durch Blockstudio die ausgewählte Vorlage und die Asset-Abhängigkeiten. Er eignet sich für statische Exporte und andere prozessinterne Abhängigkeitssammler.

PHP
add_filter(
  'blockstudio/render/dependencies',
  function($paths, $name, $block, $isEditor, $isPreview) {
    my_dependency_graph()->add($name, $paths);
    return $paths;
  },
  10,
  5
);

global

Mit diesem Filter kannst du die Ausgabe der Seite vor dem Rendern anpassen.

PHP
add_filter('blockstudio/render', function($content) {
  return $content;
});

Mit diesem Filter kannst du die Ausgabe des <head>-Tags anpassen, bevor es gerendert wird. Er wird nur ausgeführt, wenn Blockstudio die Antwort puffert, siehe bs_is_buffering().

PHP
add_filter('blockstudio/render/head', function($content) {
  return $content . '<meta name="custom" content="value">';
});

Mit diesem Filter kannst du die Ausgabe des </body> vor dem Rendern anpassen.

PHP
add_filter('blockstudio/render/footer', function($content) {
  return $content . '<script>console.log("loaded")</script>';
});

Fehlerbehandlung

error/logged

Diese Aktion wird ausgelöst, nachdem ein Fehler protokolliert wurde. Verwende sie, um Fehler an externe Protokollierungsdienste zu senden.

PHP
add_action('blockstudio/error/logged', function($message, $level, $context) {
  if ($level === 'error') {
    my_external_logger($message, $context);
  }
}, 10, 3);

error/exception

Diese Aktion wird ausgelöst, nachdem eine Ausnahme behandelt wurde.

PHP
add_action('blockstudio/error/exception', function($exception, $context) {
  my_error_tracker($exception);
}, 10, 2);

Datenbank

Alle Datenbank-Hooks erhalten ein einzelnes $params-Array.

db/before_create

Aktion, die vor dem Erstellen eines Eintrags ausgelöst wird.

PHP
add_action('blockstudio/db/before_create', function($params) {
  // $params: block, schema, data, storage
});

db/after_create

Aktion, die nach dem Erstellen eines Eintrags ausgelöst wird.

PHP
add_action('blockstudio/db/after_create', function($params) {
  // $params: block, schema, record, storage
  wp_mail($params['record']['email'], 'Welcome!', 'Thanks for subscribing.');
});

db/before_update

Aktion, die vor dem Aktualisieren eines Eintrags ausgelöst wird.

PHP
add_action('blockstudio/db/before_update', function($params) {
  // $params: block, schema, id, data, storage
});

db/after_update

Aktion, die nach dem Aktualisieren eines Eintrags ausgelöst wird.

PHP
add_action('blockstudio/db/after_update', function($params) {
  // $params: block, schema, id, record, storage
});

db/before_delete

Aktion, die vor dem Löschen eines Eintrags ausgelöst wird.

PHP
add_action('blockstudio/db/before_delete', function($params) {
  // $params: block, schema, id, storage
});

db/after_delete

Aktion, die nach dem Löschen eines Eintrags ausgelöst wird.

PHP
add_action('blockstudio/db/after_delete', function($params) {
  // $params: block, schema, id, storage
});

RPC

Alle RPC-Hooks erhalten ein einzelnes $params-Array.

rpc/before_call

Aktion, die vor dem Aufruf einer RPC-Funktion ausgelöst wird.

PHP
add_action('blockstudio/rpc/before_call', function($params) {
  // $params: block, function, params
});

rpc/after_call

Aktion, die nach dem Aufruf einer RPC-Funktion ausgelöst wird.

PHP
add_action('blockstudio/rpc/after_call', function($params) {
  // $params: block, function, params, result
});