Vai al contenuto

Hook di PHP

Di seguito trovate l’elenco di tutti gli hook PHP disponibili per estendere o modificare le funzionalità del plugin.

Percorso

Questo filtro consente di modificare il percorso della cartella del blocco. Per impostazione predefinita, si trova in blockstudio nel tema attivo. In alternativa, è possibile creare una nuova istanza per più directory sorgente.

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

Inizializzazione

globale

Questa azione viene eseguita dopo che il plugin ha registrato tutti i blocchi.

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

istanza

Questa azione viene eseguita dopo che il plugin ha registrato tutti i blocchi di un’istanza specifica. Il segmento $instance è il percorso dell’istanza relativo a 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

Questa azione viene eseguita prima che il plugin registri tutti i blocchi.

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

global/before/$instance

Questa azione viene eseguita prima che il plugin registri tutti i blocchi di un’istanza specifica.

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

Blocchi

rendering

Questo filtro consente di modificare l’output di un blocco prima del rendering.

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

metadati

Questo filtro consente di modificare i dati del file block.json prima che venga registrato.

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

Il codice sopra modifica l’icona di tutti i blocchi il cui nome inizia con marketing.

condizioni

Questo filtro consente di aggiungere condizioni personalizzate utilizzabili nei blocchi. A ogni tipo di condizione corrisponde un valore che l’editor confronta con il value della condizione. Consultate Condizioni personalizzate.

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

attributi

Questo filtro modifica la definizione di un campo prima che il blocco venga registrato. La definizione filtrata determina il controllo nell’editor e la convalida del valore al momento del rendering. Per ulteriori informazioni, consultate Filtraggio.

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

attributes/render

Questo filtro modifica il valore di un campo prima che venga passato al template del blocco. Viene eseguito una volta per campo e riceve tre argomenti: $value (il valore risolto), $key (la chiave del campo, come usata in $a) e $block (l’array di dati del blocco che i template ricevono come $block o $b). Registratelo con tre argomenti accettati. Per maggiori informazioni, consultate Filtri.

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

Un campo files restituisce ogni immagine con un array sizes contenente URL, larghezza e altezza di full e di ogni dimensione immagine registrata, ad esempio $image['sizes']['thumbnail'] e $image['sizes']['thumbnail-width']. Per ogni immagine, ogni dimensione comporta una chiamata wp_get_attachment_image_src(), quindi i relativi filtri restano applicati. I template che non leggono mai sizes possono eliminare l’elenco o ridurlo.

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 è l’elenco dei nomi delle dimensioni, con full per primo (vuoto se non sono registrate dimensioni intermedie). $id è l’ID dell’allegato e $size la dimensione richiesta per il valore url. Il filtro modifica l’array sizes di ogni valore files nella richiesta. In sua assenza, l’array resta invariato.

Restituite i nomi delle dimensioni come stringhe. Le voci non valide vengono ignorate, i nomi duplicati vengono risolti una sola volta e un valore restituito che non sia un array salta le dimensioni. La proprietà url richiesta e le altre proprietà dell’allegato restano invariate. Questo hook non viene eseguito per un campo files con returnFormat: "url", che non crea una mappa delle dimensioni.

attributes/validate

Modificate i risultati delle chiamate esplicite a bs_validate_block(), per esempio quando un filtro di rendering personalizzato risolve riferimenti memorizzati. Questo non abilita la convalida automatica durante i salvataggi o il rendering.

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

Restituite un elenco di risultati. Il filtro non viene chiamato quando il blocco non ha campi Blockstudio o estensioni corrispondenti (null).

attributes/schema

Modificate lo Schema JSON restituito da bs_block_schema(), ad esempio quando un filtro di rendering personalizzato risolve riferimenti memorizzati.

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

Restituisce l’array dello schema. Il filtro non viene chiamato se il blocco non ha campi Blockstudio né estensioni corrispondenti (null).

attributes/populate

Questo filtro consente di aggiungere dati personalizzati alle opzioni di un campo checkbox, select o radio. Per ulteriori informazioni, consultate Compilazione delle opzioni.

Il filtro riceve un argomento: un array di tutti i set di dati personalizzati, indicizzati con il nome usato in "populate": {"type": "custom", "custom": "myCustomOptions"}.

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

Questo filtro consente di modificare l’output del contenuto useBlockProps.

Tutti i filtri dei componenti (use_block_props, inner_blocks e rich_text) ricevono il blocco come ultimo argomento. $block è il WP_Block_Type registrato per il blocco sottoposto a rendering, quindi $block->name è il nome del blocco, per esempio acme/hero.

$props è una stringa di attributi HTML, non un array. Nel frontend è il risultato di get_block_wrapper_attributes(), per esempio class="wp-block-acme-hero my-class". Nell’editor è l’attributo class dell’elemento. Restituite una stringa. Nell’editor viene applicato solo l’attributo class della stringa restituita.

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

Questo filtro consente di modificare l’output del contenuto <InnerBlocks />.

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

Questo filtro consente di rimuovere il wrapper <InnerBlocks /> dal frontend.

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

components/rich_text/render

Questo filtro consente di modificare l’output del contenuto <RichText />. Riceve il valore dell’attributo e il blocco.

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

Tag dei blocchi

blockstudio/block_tags/builders

Questo filtro registra builder di array di blocchi usati dai tag dei blocchi e dai blocchi personalizzati selezionati tramite blockstudio/parser/element_mapping. Ogni builder riceve gli attributi analizzati e il contenuto interno grezzo.

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);

I filtri compatibili blockstudio/block_tags/renderers e blockstudio/parser/renderers vengono eseguiti dopo questo hook e possono sovrascrivere lo stesso nome di blocco.

blockstudio/block_tags/tag_aliases

Questo filtro consente di registrare tag di authoring personalizzati con trattini, che vengono risolti nei nomi reali dei blocchi prima del fallback ai tag grezzi HTML. È utile quando un tema vuole una sintassi di tag concisa e specifica del progetto, continuando a renderizzare blocchi standard Blockstudio o blocchi del core.

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

Questo filtro consente di mappare abbreviazioni di prefisso a uno o più namespace di blocchi. Ogni chiave è un prefisso in minuscolo senza trattini. Ogni valore può essere una stringa di namespace o un elenco ordinato di namespace.

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> si risolve in theme-components/card. <theme-button> prova prima theme-components/button, poi passa a bsui/button. Le voci blockstudio/block_tags/tag_aliases esplicite hanno la precedenza per lo stesso tag e i tag con prefisso non risolti restano invariati.

I prefissi si combinano: se un tag con prefisso non si risolve direttamente e il suo slug è a sua volta un tag di prefisso registrato, la risoluzione prosegue ricorsivamente. Con theme => ['theme-components'] e ui => ['bsui'], <theme-ui-input> passa al prefisso ui e si risolve in bsui/input. I tag di prefisso e alias registrati vengono renderizzati anche nell’output dei template dei blocchi, non solo nel contenuto delle pagine.

Impostazioni

percorso

Questo filtro consente di modificare il percorso del file blockstudio.json. Per impostazione predefinita, si trova in blockstudio.json nel tema attualmente attivo.

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

users/ids

Questo filtro consente di abilitare l’editor per ID utente specifici.

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

users/roles

Questo filtro consente di abilitare l’editor per ruoli utente specifici.

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

assets/enqueue

Questo filtro consente di abilitare o disabilitare l’accodamento degli asset nel frontend e nell’editor.

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

assets/reset/enabled

Questo filtro consente di abilitare o disabilitare la rimozione degli stili dei blocchi del core WordPress e del ripristino del layout delle utilità dell’editor.

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

assets/reset/full_width

Questo filtro consente di controllare quali tipi di contenuto usano la modifica a larghezza intera.

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

assets/minify/css

Questo filtro consente di abilitare o disabilitare la minificazione di CSS.

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

assets/minify/js

Questo filtro consente di abilitare o disabilitare la minificazione di JS.

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

assets/process/scss

Questo filtro consente di abilitare o disabilitare l’elaborazione di SCSS nei file .css.

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

assets/process/scss_files

Questo filtro consente di abilitare o disabilitare la conversione dei file .scss in CSS.

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

assets/output

Questo filtro consente di controllare dove vengono scritti gli asset dei blocchi compilati.

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

assets/inline_limit

Questo filtro consente di controllare quanti byte di CSS esterno del blocco vengono incorporati in ogni pagina.

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

cache/enabled

Questo filtro consente di abilitare o disabilitare tutte le cache runtime basate su file di Blockstudio e degli asset dell’editor.

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

cache/path

Questo filtro consente di modificare la directory della cache basata su file Blockstudio.

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

cache/namespace_grace

Questo filtro consente di modificare per quanto tempo viene conservato uno namespace della cache ritirato prima della sua eliminazione.

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

githooks/commit

Questo filtro indica se l’hook di commit PHPStan gestito da Blockstudio è abilitato.

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

content/enabled

Questo filtro consente di abilitare o disabilitare Content Sync.

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

content/id

Questo filtro consente di impostare lo namespace proprietario di Content Sync.

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

content/path

Questo filtro consente di impostare la directory dei file di Content Sync.

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

content/include_page_sync_managed

Questo filtro consente di includere o escludere i contenuti gestiti da Page Sync.

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

content/authors

Questo filtro consente di configurare la gestione degli autori di Content Sync.

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

content/post_types

Questo filtro consente di configurare gli elenchi di tipi di contenuto consentiti per Content Sync.

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

content/taxonomies

Questo filtro consente di configurare gli elenchi di tassonomie consentite per Content Sync.

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

content/media

Questo filtro consente di configurare la gestione dei media di Content Sync.

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

tailwind/enabled

Questo filtro consente di abilitare o disabilitare Tailwind.

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

tailwind/config

Questo filtro consente di aggiungere una configurazione personalizzata di Tailwind CSS.

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

tailwind/output

Questo filtro consente di scegliere se l’output di Tailwind CSS deve essere incorporato o collegato.

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

ui/enabled

Questo filtro consente di abilitare o disabilitare i componenti UI inclusi.

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

editor/format_on_save

Questo filtro consente di abilitare o disabilitare la formattazione del codice al salvataggio.

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

editor/assets

Questo filtro consente di accodare altri asset nell’editor.

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

editor/markup

Questo filtro consente di aggiungere markup all’editor.

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

block_editor/disable_loading

Questo filtro consente di disabilitare il caricamento dei blocchi nell’editor dei blocchi.

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

block_editor/enhance

Questo filtro consente di abilitare le funzionalità dell’editor Blockstudio, come stili di messa a fuoco più puliti e contorni al passaggio del mouse o alla selezione.

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

block_editor/css_classes

Questo filtro consente di aggiungere fogli di stile le cui classi saranno disponibili nel campo delle classi.

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

block_editor/css_variables

Questo filtro consente di aggiungere fogli di stile le cui variabili CSS saranno disponibili per il completamento automatico nel campo del codice.

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

block_editor/blocks/allow

Questo filtro consente di controllare quali nomi di blocco sono consentiti nell’inseritore.

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

block_editor/blocks/deny

Questo filtro consente di rimuovere nomi di blocco dall’inseritore.

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

block_editor/blocks/directory

Questo filtro consente di abilitare o disabilitare gli asset della directory dei blocchi WordPress nell’editor.

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

block_editor/blocks/categories/allow

Questo filtro consente di controllare quali slug delle categorie di blocchi restano disponibili.

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

block_editor/blocks/categories/deny

Questo filtro consente di rimuovere slug delle categorie di blocchi dall’inseritore.

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

block_editor/blocks/categories/rename

Questo filtro consente di rinominare le etichette delle categorie di blocchi in base allo slug.

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

block_editor/blocks/categories/order

Questo filtro consente di ordinare gli slug delle categorie di blocchi nell’inseritore.

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

block_editor/blocks/styles/deny

Questo filtro consente di annullare la registrazione degli stili dei blocchi registrati da PHP, in base al nome del blocco.

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

Questo filtro consente di nascondere altri widget legacy dal blocco dei widget legacy.

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

block_editor/patterns/core

Questo filtro consente di abilitare o disabilitare i pattern dei blocchi del core WordPress.

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

block_editor/patterns/remote

Questo filtro consente di abilitare o disabilitare i pattern remoti dalla directory dei pattern WordPress.

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

block_editor/patterns/theme

Questo filtro consente di abilitare o disabilitare i pattern dei blocchi forniti dal tema.

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

block_editor/patterns/blockstudio

Questo filtro consente di abilitare o disabilitare i pattern basati su file Blockstudio.

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

block_editor/patterns/categories/allow

Questo filtro consente di controllare quali slug delle categorie di pattern restano disponibili.

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

block_editor/patterns/categories/deny

Questo filtro consente di rimuovere slug delle categorie di pattern dall’inseritore dei pattern.

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

block_editor/patterns/categories/rename

Questo filtro consente di rinominare le etichette delle categorie di pattern in base allo slug.

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

block_editor/patterns/categories/order

Questo filtro consente di ordinare gli slug delle categorie di pattern nell’inseritore.

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

block_editor/media/openverse

Questo filtro consente di abilitare o disabilitare la categoria media Openverse nell’inseritore dei media dell’editor dei blocchi.

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

block_editor/media/image_sizes/allow

Questo filtro consente di controllare quali nomi di dimensioni delle immagini restano disponibili nei controlli dei media dell’editor.

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

block_editor/media/image_sizes/deny

Questo filtro consente di rimuovere nomi di dimensioni delle immagini dai controlli dei media dell’editor.

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

ai/enable_context_generation

Questo filtro consente di abilitare o disabilitare la generazione del file di contesto per l’integrazione con gli strumenti LLM. Se abilitato, il file di contesto riunisce in un’unica fonte i dati aggiornati dei blocchi, le impostazioni Blockstudio dell’installazione corrente, tutti gli schemi pertinenti e la documentazione Blockstudio, da usare con gli strumenti di sviluppo basati sull’IA.

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

block_tags/enabled

Questo filtro consente di abilitare o disabilitare il rendering dei tag dei blocchi a livello di pagina.

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

block_tags/prefixes

Questo filtro consente di registrare abbreviazioni che associano i prefissi agli namespace per i tag dei blocchi.

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

dev/grab/enabled

Questo filtro consente di abilitare o disabilitare il selettore di elementi.

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

dev/perf

Questo filtro consente di abilitare o disabilitare il profiler delle prestazioni.

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

dev/canvas/enabled

Questo filtro consente di abilitare o disabilitare il canvas.

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

dev/canvas/admin_bar

Questo filtro consente di mostrare o nascondere la barra di amministrazione WordPress sul canvas.

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

WPML

blockstudio/wpml/config/label

Filtra l’etichetta di ogni chiave scritta da wp bs wpml config. Per l’array di contesto, vedere Modificare le etichette.

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

Canvas

blockstudio/canvas/inventory

Questo filtro modifica l’inventario che Canvas restituisce per una selezione. Il callback riceve il DTO dell’inventario, la selezione originale e le opzioni con cui è stato chiamato.

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

blockstudio/canvas/documents

Questo filtro modifica i documenti renderizzati che Canvas restituisce, con gli stessi tre argomenti del filtro dell’inventario.

blockstudio/canvas/item_loaded

Questa azione viene eseguita per ogni record dell’inventario al suo caricamento e riceve il tipo di inventario, l’ID canonico del record e il record normalizzato.

blockstudio/canvas/source_compiled

Questa azione viene eseguita dopo la compilazione di un file sorgente per Canvas e riceve il percorso del sorgente selezionato e il record sorgente canonico.

Componenti UI inclusi

blockstudio/ui/directories

Questo filtro modifica le directory analizzate per individuare i componenti UI inclusi.

blockstudio/ui/inventory

Questo filtro modifica l’inventario pubblico delle famiglie UI.

blockstudio/ui/examples

Questo filtro modifica i record di esempio di UI e riceve gli esempi e l’inventario pubblico UI da cui sono stati ricavati.

Topologia

blockstudio/blocks/topology_refreshed

Questa azione viene eseguita dopo la ricostruzione della topologia dei blocchi.

blockstudio/pages/topology_refreshed

Questa azione viene eseguita dopo la ricostruzione della topologia della pagina.

blockstudio/pages/layout_error

Questa azione viene eseguita quando il rendering del layout di una pagina non riesce, invece di fallire senza segnalarlo.

Runtime

blockstudio/runtime/initialized

Questa azione viene eseguita quando il runtime ha risolto la propria configurazione.

blockstudio/runtime/changed

Questa azione viene eseguita quando cambia l’identità runtime risolta, determinando lo spostamento degli namespace della cache e dello stato di prerendering statico.

blockstudio/performance/default_config

Questo filtro modifica i valori predefiniti delle prestazioni prima che vengano applicati quelli del progetto blockstudio.json.

Contenuto

blockstudio/content/orphan_action

Questo filtro decide cosa fa Content Sync con un record che non ha più una sorgente.

Bootstrap

blockstudio/url

Questo filtro modifica il URL pubblico usato da Blockstudio per gli asset dell’editor e di amministrazione. Le integrazioni Composer devono registrarlo prima di caricare il file di autoload di Blockstudio. Il secondo argomento è la directory fisica del pacchetto.

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

Cache runtime

blockstudio/cache/dir

Questo filtro riceve la directory di base della cache risolta, prima che venga aggiunto uno scope runtime, degli asset dell’editor o di un’altra cache.

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

blockstudio/cache/context

Questo filtro aggiunge una variante serializzabile del runtime alle identità della cache. Usatelo quando la stessa sorgente di rilevamento può selezionare inventari logici diversi.

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

Questo filtro modifica l’identità della directory di rete/blog per gli host con un proprio confine tenant. Il valore restituito viene ripulito prima dell’uso.

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

Questo filtro aggiunge informazioni sull’host che influiscono su ogni oggetto in uno scope runtime. Le impronte della sorgente specifiche di un elemento devono invece essere passate come dipendenze esplicite dal relativo API.

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

Filtra il numero di secondi per cui è possibile riutilizzare un’istantanea convalidata del monitoraggio dei file senza eseguire un’altra scansione stat del filesystem. Il valore predefinito è 0 negli ambienti locali e di sviluppo e 20 negli altri.

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

blockstudio/cache/build_wait_budget

Filtra per quanto tempo, in millisecondi, una richiesta attende che un builder concorrente pubblichi la cache runtime o aggiorni una scelta popolata prima di passare a una modalità degradata. Il valore predefinito è 5000 per le ricostruzioni strutturali e 4000 per gli aggiornamenti delle scelte.

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

blockstudio/cache/populate_debounce

Filtra per quanti secondi un picco di scritture di contenuti, termini, utenti o metadati viene accorpato in un unico aggiornamento delle scelte popolate. La prima scrittura dopo un periodo di inattività aggiorna immediatamente; l’ultima scrittura del picco viene recepita allo scadere della finestra. Il valore predefinito è 30. Restituite 0 per aggiornare a ogni scrittura.

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

blockstudio/cache/populate_ignored_meta_keys

Filtra le chiavi meta le cui scritture non aggiornano mai le scelte popolate. Per impostazione predefinita, sono le chiavi che WordPress scrive per tenere traccia delle modifiche e degli accessi: _edit_lock, aggiornate dall’editor e da Heartbeat mentre un articolo è aperto; _edit_last, scritta insieme al salvataggio di un articolo, che già attiva un aggiornamento; e session_tokens, scritta all’accesso e alla disconnessione. Aggiungete le chiavi che cambiano spesso ma non influiscono mai su una query di popolamento.

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

blockstudio/cache/max_files_per_scope

Filtra il numero di payload pubblicati conservati da ogni scope della cache runtime.

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

blockstudio/cache/compress

Filtra se un payload della cache usa dati serializzati compressi invece di un array PHP semplice. Per impostazione predefinita, solo i payload fino a 1 MiB usano il formato semplice, e solo quando la memoria condivisa OPcache attiva può memorizzare nella cache la destinazione. Gli altri processi, i file esclusi e i payload più grandi usano la compressione.

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

La restituzione di false ignora anche il limite di dimensione. Può essere utile quando WP-CLI senza opcache.enable_cli precarica i file per i worker web con OPcache, ma ogni lettore senza OPcache analizzerà l’array generato. Mantenete la compressione per i payload condivisi di grandi dimensioni, a meno che il costo aggiuntivo in memoria sia accettabile. Per le protezioni predefinite, vedere formati dei payload della cache.

blockstudio/cache/protected_paths

La pulizia per conservazione non deve mai eliminare i percorsi della cache. Blockstudio la inizializza con ogni file a cui fa riferimento la mappa di distribuzione anticipata installata.

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

Questa azione segnala uno scope e un esito della cache condivisa, come hit, build, miss-stale, stale-last-good o 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

Questo filtro riceve la decisione finale sulla sicurezza anonima, insieme agli input del server e dei cookie. La restituzione di true esclude sempre la distribuzione statica e la generazione.

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

Questo filtro fornisce o modifica l’inventario pubblico completo di URL usato dal warmer pianificato e dagli strumenti espliciti per i grafi.

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

Ciò che restituisce il filtro non è l’inventario finale. Il risultato viene sottoposto a un controllo di memorizzabilità che elimina tutto ciò che corrisponde a un percorso dinamico configurato e tutto ciò che viene escluso per impostazione predefinita: /wp-admin, /wp-json, /wp-login.php, /xmlrpc.php, qualsiasi percorso contenente /feed/ e i risultati di ricerca sotto il percorso di base della ricerca nella home del sito (per impostazione predefinita /search/). Una URL aggiunta può quindi essere scartata senza preavviso. Se manca un percorso che vi aspettate di trovare nell’inventario generato, verificate che rispetti queste regole prima di concludere che il filtro non sia stato eseguito.

blockstudio/static_prerender/render_internal

Questo filtro implementa il trasporto batch opzionale in-process. Restituite un array di risultati normalizzato oppure lasciate invariato il valore affinché il renderer utilizzi il fallback HTTP configurato. Il risultato include html e, facoltativamente, status, dependencies, virtualHashes e headers; le intestazioni indicate in performance.staticPrerender.replayHeaders vengono memorizzate insieme al documento.

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

Questo filtro prende la decisione finale dopo che Blockstudio ha verificato che l’output sia un documento HTML completo, privo del marcatore no-cache e con uno stato della risposta osservato positivo. Il terzo argomento è lo stato osservato o null se non ne è stato dichiarato uno.

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

Questa azione segnala gli esiti del prerendering statico, inclusi hit, miss, scritture, scritture dei grafi, voci obsolete ed errori.

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

blockstudio/tailwind/cache_max_files

Filtra il numero massimo di voci Tailwind CSS compilate. Il valore predefinito è 1000.

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

blockstudio/tailwind/cache_max_age

Filtra l’età massima, in secondi, delle voci Tailwind CSS compilate. Il valore predefinito è 30 giorni e il minimo è un’ora.

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

Amministrazione

abilitato

Questo filtro consente di abilitare o disabilitare la pagina di amministrazione Blockstudio in Strumenti > Blockstudio.

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

Asset

editor/canvas/body_class

Quando il ripristino degli asset è abilitato, questo filtro modifica le classi del body del frontend ripulite e copiate nel canvas dell’editor dei blocchi.

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

abilita

Questo filtro consente di disabilitare l’elaborazione e l’accodamento degli asset di un tipo specifico.

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

disabilita

Questo filtro consente di disabilitare asset specifici tramite il loro ID. Gli asset corrispondenti a un ID nell’array restituito non verranno renderizzati nel frontend.

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

process/scss/import_paths

Questo filtro consente di aggiungere percorsi aggiuntivi all’istruzione @import del compilatore SCSS.

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

process/scss/prelude

Questo filtro consente di anteporre codice Sass condiviso a ogni file SCSS prima della compilazione.

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

Questo filtro consente di modificare il contenuto del file CSS prima della compilazione.

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

process/js/content

Questo filtro consente di modificare il contenuto del file JS prima della compilazione.

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

Buffer

abilitato

Blockstudio memorizza nel buffer la risposta del frontend, così i tag di stile e script dei blocchi renderizzati nel body possono essere spostati nell’head e nel footer e Tailwind può analizzare il documento completo. Il buffering comporta la conservazione e l’analisi dell’intero documento a ogni richiesta del frontend; un sito che non renderizza asset di blocchi Blockstudio e non usa Tailwind può restituire false per saltare entrambe le operazioni.

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

Il buffering è disattivato anche nell’amministrazione e nell’anteprima del Personalizzatore. Chiamate bs_is_buffering() da wp_enqueue_scripts o successivamente per sapere se la risposta corrente è sottoposta a buffering. Restituisce false prima che la decisione venga presa in template_redirect.

output

Questo filtro riceve il documento HTML completo memorizzato nel buffer prima dell’invio. Il meccanismo di spostamento degli asset di Blockstudio viene eseguito con priorità 1000000 e la compilazione di Tailwind con priorità 999999; eseguitelo prima per vedere il documento prima di queste operazioni o dopo per vedere l’output finale.

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

Rendering

dipendenze

Questo filtro segnala il template selezionato e le dipendenze degli asset ogni volta che Blockstudio renderizza un blocco. È utile per gli esportatori statici e per altri strumenti di raccolta delle dipendenze in-process.

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

globale

Questo filtro consente di modificare l’output della pagina prima del rendering.

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

Questo filtro consente di modificare l’output del tag <head> prima del rendering. Viene eseguito solo quando Blockstudio esegue il buffering della risposta; vedere bs_is_buffering().

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

Questo filtro consente di modificare </body> prima del rendering.

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

Gestione degli errori

error/logged

Azione eseguita dopo la registrazione di un errore. Usatela per inviare gli errori a servizi di logging esterni.

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

error/exception

Azione eseguita dopo la gestione di un’eccezione.

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

Database

Tutti gli hook del database ricevono un singolo array $params.

db/before_create

Azione eseguita prima della creazione di un record.

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

db/after_create

Azione eseguita dopo la creazione di un record.

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

Azione eseguita prima dell’aggiornamento di un record.

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

db/after_update

Azione eseguita dopo l’aggiornamento di un record.

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

db/before_delete

Azione eseguita prima dell’eliminazione di un record.

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

db/after_delete

Azione eseguita dopo l’eliminazione di un record.

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

RPC

Tutti gli hook RPC ricevono un singolo array $params.

rpc/before_call

Azione eseguita prima della chiamata a una funzione RPC.

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

rpc/after_call

Azione eseguita dopo la chiamata a una funzione RPC.

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