Dennis · 23 luglio 2026
Blockstudio 7.5
Blockstudio La versione 7.5 completa il flusso di lavoro basato sui file di Blockstudio: tipi di campi personalizzati, template dell’Editor del sito basati su file, isole di blocchi, archiviazione del database Storh, sorgenti di rilevamento logiche, tag dei blocchi componibili e percorsi di deployment e runtime più rapidi.
I campi personalizzati riutilizzabili consentono già ai progetti di definire una volta un gruppo di campi esistenti e riutilizzarlo con type: "custom/{name}". I tipi di campi personalizzati risolvono un problema diverso. Consentono a un tema o plugin di registrare un nuovo tipo di campo con spazio dei nomi, fornire un proprio controllo nell’editor e archiviare il valore come normali dati Blockstudio.
In breve:
- Fonti di individuazione logiche: i runtime possono fornire un inventario logico dei temi composto, inclusi provenienza e identità della cache, mentre Blockstudio mantiene la gestione dell’individuazione, della risoluzione dei file fratelli, degli asset generati, di Canvas e del comportamento di Tailwind.
- Registro dei tipi di campo PHP: temi e plugin possono registrare tipi di campo con namespace, come
acme/dimensionsconbs_register_field_type()o il filtroblockstudio/field_types. - Registro dei controlli dell’editor: gli script personalizzati dell’editor possono chiamare
window.blockstudio.registerFieldType()e visualizzare il controllo React corrispondente nel normale Blockstudio UI del campo. - Valori strutturati: i campi personalizzati possono memorizzare stringhe, numeri, valori booleani, array o oggetti senza convertire i valori degli oggetti tramite la normalizzazione dei campi di opzione.
- Supporto per l’archiviazione: i campi personalizzati basati su post meta e opzioni possono dichiarare il tipo del valore e lo schema REST, inclusi valori di tipo oggetto e array.
- Integrazione nativa: i tipi di campo personalizzati funzionano in gruppi, schede, ripetitori, campi personalizzati riutilizzabili, template e percorsi di template delle estensioni.
- Template dell’Editor del sito: i temi possono definire sorgenti
wp_templateewp_template_partda file di templatetemplate.json,part.jsone Blockstudio. - Isole di blocchi: i blocchi possono visualizzare prima un involucro compatibile con la cache e poi idratare o recuperare in batch frammenti specifici della richiesta dopo il caricamento della pagina.
- Archiviazione nel database Storh:
bs.dbpuò usare negli upload un archivio indicizzato con un file per record, mantenendo gli ID interi pubblici e consentendo la migrazione da JSONC a Storh tramite WP-CLI. - Miglioramenti a parser e bsui: i paragrafi richtext mappati richiedono meno codice personalizzato per il parser,
InnerBlockspuò usareallowedBlockstokenizzati, l’outputbs_render_block()annidato corrisponde al rendering frontend nelle anteprime dell’editor ebsui/buttonoffre icone e hook di stile più semplici. - Tag di blocco componibili: i tag con prefisso possono essere risolti tramite un altro prefisso (da
<theme-ui-input>absui/input); inoltre, i tag con prefisso e alias vengono visualizzati nell’output dei template di blocco, non solo nel contenuto delle pagine. - Cache delle build compatibili con l’host: le cache del runtime e dell’editor ora vengono salvate per impostazione predefinita fuori dagli upload, supportano percorsi configurabili e rimuovono le voci obsolete, evitando così che i progetti di lunga durata accumulino file di cache.
- Riconciliazione incrementale delle pagine: gli strumenti di deployment possono riconciliare l’inventario completo delle pagine basate su file, ignorare i post invariati, indicare esattamente le modifiche e salvare un’identità della sorgente verificata dopo l’attivazione.
- Rendering più rapido con cache già popolata: le cache runtime valide vengono caricate prima dell’individuazione, le richieste a freddo simultanee pubblicano un unico risultato atomico e Tailwind mantiene una cache delle dimensioni del sito con uno stato del compilatore riutilizzabile.
- Rendering batch sicuro: gli esportatori possono reimpostare lo stato di rendering specifico della richiesta tra un documento e l’altro senza ricostruire l’individuazione e raccogliere le dipendenze delle sorgenti durante il rendering dei blocchi.
Nuove funzionalità
La versione 7.5 introduce un’ampia serie di nuove funzionalità per l’individuazione, i template e l’archiviazione.
Sorgenti di individuazione logiche
Blockstudio normalmente individua i file nelle directory fisiche dei temi. La versione 7.5 aggiunge la sorgente di livello inferiore API per i runtime che assemblano un tema da overlay, anteprime, file generati, mount remoti o altri inventari composti.
Un’integrazione può fornire un albero logico finale dei file, mentre Blockstudio mantiene la gestione del comportamento di blocchi, campi, pagine, pattern, Editor del sito, Canvas, asset e Tailwind:
use Blockstudio\Inventory_Discovery_Source;
add_filter(
'blockstudio/discovery/sources',
function (array $sources, string $context): array {
if ('blocks' !== $context) {
return $sources;
}
return [
new Inventory_Discovery_Source(
'preview:feature-card',
'/runtime-preview/feature-card/blockstudio',
[
'card/block.json' => [
'path' => '/theme/blockstudio/card/block.json',
'provenance' => ['layer' => 'parent'],
],
'card/index.php' => [
'path' => '/runtime-preview/feature-card/blockstudio/card/index.php',
'provenance' => ['layer' => 'preview'],
],
],
'preview-fingerprint'
),
];
},
10,
2
);
I percorsi logici restano stabili anche quando i file fratelli provengono da radici fisiche diverse. Gli ID e le impronte digitali delle sorgenti alimentano le identità della cache del runtime e di Tailwind; gli input osservati invalidano la cache e la provenienza determina dove è possibile scrivere i file generati. La sorgente predefinita del filesystem non cambia per i temi normali.
Template dell’Editor del sito basati su file
Le pagine e i pattern consentono già ai team di mantenere in file le strutture dei contenuti. La versione 7.5 estende questo modello allo stesso Editor del sito.
theme/
templates/
front-page/
template.json
index.php
parts/
header/
part.json
index.php
{
"slug": "front-page",
"title": "Front Page"
}
<div class="site-shell">
<block name="core/template-part" slug="header" />
<main>
<h1>Welcome</h1>
<block name="core/post-content" />
</main>
</div>
Blockstudio compila la sorgente con lo stesso parser usato per pagine e pattern, quindi espone il risultato a WordPress come normale template o parte di template dell’Editor del sito. L’Editor del sito mostra il template, il frontend può visualizzarlo e WordPress continua a gestire le personalizzazioni.
Quest’ultimo aspetto è importante. I template basati su file fungono da sorgente di fallback. Se un utente salva un template nell’Editor del sito, WordPress crea la normale personalizzazione nel database wp_template o wp_template_part, che ha la precedenza. Reimpostando la personalizzazione, la versione più recente presente nel file torna visibile.
Deployment incrementale delle pagine
Nella versione 7.5, le pagine basate su file hanno acquisito un API di riconciliazione per il deployment. Dalla versione 7.6.2, questi API e wp bs pages sync espliciti sono gli unici punti di ingresso per la sincronizzazione; le normali richieste non applicano mai le modifiche alle sorgenti:
$report = Blockstudio\Pages::reconcile([
'authoritative' => true,
'plan_valid' => true,
'source' => [
'commit' => $commit,
'dirtyHash' => $dirtyHash,
],
]);
Il processo individua l’intero inventario di pagine desiderato, confronta i contenuti e le impronte digitali del motore di sincronizzazione e segnala le pagine create, aggiornate, invariate, rimosse e non riuscite. Per le pagine con impronte digitali identiche non vengono scritti post o postmeta. Le pagine gestite mancanti vengono rimosse solo dopo che l’individuazione è terminata senza errori.
La riconciliazione restituisce un’identità deterministica della sorgente, ma non contrassegna un deployment come riuscito. Gli strumenti di deployment salvano tale identità solo dopo aver attivato e verificato i file e i percorsi corrispondenti. L’avvio ordinario di WP-CLI registra i tipi di post della raccolta e le regole di riscrittura memorizzati nella cache, senza individuare e sincronizzare tutte le pagine.
Isole di blocchi
La maggior parte dei blocchi di Blockstudio viene renderizzata sul server. È una soluzione adatta a WordPress, ma crea un problema di cache noto: un singolo blocco personalizzato può rendere difficile memorizzare nella cache l’intera pagina.
Le isole di blocchi separano questo confine a livello di blocco.
{
"name": "acme/cart-count",
"blockstudio": {
"island": "dynamic"
}
}
Al primo caricamento, un’isola dinamica visualizza solo un segnaposto compatibile con la cache. Il browser invia poi un’unica richiesta in batch per tutte le isole dinamiche pronte nella pagina e Blockstudio visualizza quei frammenti nel contesto della richiesta effettiva del visitatore.
In questo modo, la cache dell’intera pagina può memorizzarne l’involucro, mentre il conteggio degli articoli nel carrello, i controlli dell’account, i blocchi UI soggetti a autorizzazioni e gli altri elementi specifici dell’utente restano aggiornati.
<div class="cart-count-placeholder">Loading cart...</div>
<div class="cart-count">
<?php echo esc_html(acme_cart_count()); ?>
</div>
Per i blocchi che già visualizzano HTML compatibili con la cache e necessitano solo di un segnale di mount nel frontend, usate un’isola idratata:
{
"name": "acme/tabs",
"blockstudio": {
"island": "hydrate"
}
}
Le isole idratate non effettuano una richiesta REST. Vengono visualizzate normalmente e ricevono un evento blockstudio:island:hydrate nel frontend.
Anche i percorsi di rendering programmatico supportano le isole dinamiche:
bs_render_block([
'name' => 'acme/cart-count',
'data' => ['productId' => 42],
]);
E anche i tag di blocco:
<bs:acme-cart-count product-id="42" />
L’endpoint ha uno scopo volutamente circoscritto. Visualizza solo blocchi Blockstudio registrati, dinamici e contrassegnati esplicitamente come isole dinamiche. Gli attributi vengono filtrati secondo lo schema del blocco e la lista consentita dell’isola; ogni marcatore include una firma generata dal sito WordPress che serve la richiesta.
Archiviazione nel database Storh
Il livello database di Blockstudio supporta già tabelle, SQLite, JSONC, post meta e tipi di post personalizzati. La versione 7.5 aggiunge storage: "storh" per i progetti che vogliono un archivio basato su file, con scritture simultanee più sicure e indici derivati dallo schema, ma non vogliono che i record attivi vengano salvati accanto ai file sorgente dei blocchi.
return [
'storage' => 'storh',
'fields' => [
'title' => ['type' => 'string', 'required' => true],
'status' => ['type' => 'string'],
'count' => ['type' => 'integer'],
],
];
I record di Storh si trovano negli upload:
wp-content/uploads/blockstudio/db/my-theme-my-block/default/
L’API pubblica API resta invariata. bs.db(), REST e Db::get() restituiscono ancora valori id interi. Internamente, Blockstudio associa questi ID agli ID documento UUIDv7 di Storh, quindi il codice client esistente non deve essere modificato.
Ogni campo dichiarato nello schema viene indicizzato per i filtri di uguaglianza; i campi numerici e simili a date ricevono indici per intervallo e gli hint univoci espliciti vengono mantenuti. Per i progetti avviati con file seed JSONC, la nuova migrazione CLI mantiene il file sorgente nella posizione originale e scrive un archivio Storh equivalente:
wp bs db migrate my-theme/app subscribers --to=storh
Questo assegna a JSONC un ruolo più chiaro come semplice formato seed/configurabile da salvare nel repository, mentre Storh diventa il backend su file predefinito più adatto ai dati di produzione modificabili.
Miglioramenti a parser e bsui
La versione 7.5 perfeziona anche alcuni dettagli minori che emergono quando un progetto usa più intensamente template basati su file e UI inclusi.
La mappatura degli elementi ora gestisce il caso comune dei paragrafi richtext senza un builder personalizzato. Se <p> viene mappato a un blocco Blockstudio registrato e non core con un attributo richtext content, il testo semplice interno viene copiato in quell’attributo. I tag annidati e gli elementi figlio mappati continuano a essere analizzati come blocchi interni.
InnerBlocks accetta allowedBlocks tokenizzati nei template:
<InnerBlocks allowedBlocks="<?php echo esc_attr(wp_json_encode([
'core/paragraph',
'category:content',
'bsui/field',
])); ?>" />
I token supportati sono namespace/*, category:<slug> e @theme. Vengono espansi sul server prima che l’editor riceva il template, quindi il percorso di rendering del frontend resta invariato.
Anche gli embed programmatici sono più prevedibili. Ora bs_render_block() e bs_block() visualizzano i blocchi incorporati come HTML risolti dal frontend, anche se vengono chiamati dall’anteprima dell’editor di un altro blocco. Di conseguenza, i blocchi annidati non inseriscono componenti pseudo-<RichText /> o <InnerBlocks /> grezzi nel markup dell’anteprima.
Per UI inclusi, bsui/button ora supporta un attributo icon e iconPosition. Gli stili inline di bsui/* inclusi vengono emessi in un livello di cascata @layer bsui e le varianti dei pulsanti possono essere estese con blockstudio/ui/button/variants-style oltre che con il filtro blockstudio/blocks/attributes già disponibile.
Anche i tag di blocco sono più componibili. Un prefisso può essere risolto tramite un altro prefisso: così <theme-ui-input />, con il prefisso di progetto theme su uno namespace ui, risolve bsui/input. I tag con prefisso e alias registrati vengono ora visualizzati anche nell’output dei template di blocco, non solo nel contenuto delle pagine; un template può quindi produrli direttamente anziché chiamare bs_render_block().
I builder di blocchi personalizzati registrati tramite blockstudio/block_tags/builders partecipano in modo coerente anche all’analisi dei tag e degli elementi mappati. I filtri espliciti del renderer vengono comunque eseguiti dopo e possono sovrascrivere il builder.
Richieste con cache già popolata ed esportazioni più rapide
Per impostazione predefinita, le cache del runtime e dell’editor vengono ora salvate in wp-content/blockstudio/cache anziché negli upload. Il percorso può essere modificato tramite cache.path o blockstudio/cache/dir, rendendo disponibile la cache persistente anche sugli host che bloccano i payload PHP negli upload. Anche le cache del runtime, degli asset dell’editor e di Tailwind rimuovono automaticamente le voci obsolete, evitando così che i progetti di lunga durata accumulino file di cache senza limiti sul disco.
Le richieste frontend con cache già popolata caricano ora un registro runtime valido prima di creare le sorgenti di individuazione. Si evitano così l’individuazione ricorsiva delle sorgenti, la creazione dei blocchi, l’analisi dei campi e le ripetute scansioni dell’albero per generare le chiavi della cache. Per impostazione predefinita, le richieste di produzione e staging si affidano a uno snapshot di osservazione convalidato per 20 secondi, mentre gli ambienti locali e di sviluppo verificano a ogni richiesta.
La creazione della cache vuota usa un’unica richiesta alla volta. Una richiesta crea e pubblica atomicamente il payload, mentre le richieste simultanee attendono il completamento. Per impostazione predefinita, Tailwind conserva fino a 1,000 voci compilate per 30 giorni e riutilizza lo stato di costruzione del compilatore già pronto, così un insieme di percorsi delle dimensioni di un sito non manda continuamente in rotazione una cache troppo piccola.
Gli esportatori di lunga durata possono chiamare Blockstudio\Batch_Render::reset() tra un documento e l’altro. In questo modo si azzerano i contatori, gli asset, le isole, i layout e la generazione di Tailwind specifici della richiesta, senza ricostruire l’individuazione. Il filtro blockstudio/render/dependencies espone i percorsi dei template e degli asset usati da ogni blocco renderizzato, utili per creare grafi delle dipendenze.
Affidabilità e compatibilità
Completano la versione diverse correzioni:
- Le definizioni dei campi modificate tramite
blockstudio/blocks/attributesora determinano la convalida delle opzioni durante il rendering, oltre allo schema dell’editor. Anche i valori numerici tipizzati e quelli delle opzioni booleane vengono risolti in modo coerente. - Gli wrapper dei blocchi nell’editor usano le stesse classi generate dei rendering frontend e, grazie al nuovo filtro
blockstudio/editor/canvas/body_class, Canvas può copiare le classi body frontend configurate. - Content Sync convalida il piano completo delle sorgenti prima delle scritture distruttive, limita le operazioni di rimozione all’insieme di contenuti configurato e segnala gli errori di scrittura dei file senza aggiornare lo stato di sincronizzazione dell’entità interessata.
- I pacchetti Composer inclusi nei temi attivi o nei temi genitori collegati tramite symlink recuperano gli asset dell’editor dalla URL pubblica del tema.
- Le pagine basate su file con chiave conservano i valori dei campi Blockstudio gestiti dall’editor, migrano durante la sincronizzazione il formato precedente con chiave annidata e accettano zero numerico come chiave valida.
- Le isole dinamiche verificano le firme prima dei filtri degli attributi della richiesta, ignorano il contesto della richiesta senza firma, ripristinano i visitatori autenticati della stessa origine ed evitano collisioni nella cache anonima tra utenti.
- Gli endpoint grezzi delle pagine Markdown ora rispettano la visibilità del post e la protezione tramite password.
- I controlli dell’editor gestiscono in modo più affidabile condizioni vuote, valori di selezione di tutte le caselle di controllo, aggiornamenti asincroni delle opzioni, ordine dinamico di rendering e stato RichText o WYSIWYG dei ripetitori.
Tipi di campo personalizzati
Maggiori informazioni sui tipi di campo personalizzati introdotti sopra.
Perché usare tipi di campo personalizzati?
Blockstudio dovrebbe restare utile già dalla prima installazione, ma i progetti reali spesso richiedono controlli specifici del proprio dominio: selettori di token di spaziatura, ruoli di colore del sistema di design, dimensioni responsive, sorgenti di icone, selettori di prodotti o controlli editoriali che corrispondono a un valore strutturato.
Prima della versione 7.5, questi progetti potevano combinare diversi campi integrati oppure creare una propria versione dell’editor. La versione 7.5 offre una soluzione intermedia supportata: Blockstudio gestisce il ciclo di vita del campo, mentre il progetto gestisce il controllo.
add_action('init', function () {
wp_register_script(
'acme-field-dimensions',
get_stylesheet_directory_uri() . '/fields/dimensions.js',
['blockstudio-blocks', 'wp-components', 'wp-element'],
'1.0.0',
true
);
bs_register_field_type('acme/dimensions', [
'attribute' => 'object',
'default' => [],
'editor_script' => 'acme-field-dimensions',
'storage' => [
'type' => 'object',
'rest_schema' => [
'type' => 'object',
'additionalProperties' => ['type' => 'string'],
],
],
]);
});
const { createElement: el } = wp.element;
const { TextControl } = wp.components;
window.blockstudio.registerFieldType('acme/dimensions', {
component(props) {
const value =
props.value &&
typeof props.value === 'object' &&
!Array.isArray(props.value)
? props.value
: {};
const sides = props.sides || ['top', 'right', 'bottom', 'left'];
return el(
'div',
{},
sides.map((side) =>
el(TextControl, {
key: side,
label: side,
value: value[side] || '',
onChange(nextValue) {
props.onChange({
...value,
[side]: nextValue,
});
},
}),
),
);
},
});
Il campo può quindi essere usato in block.json come un campo nativo:
{
"blockstudio": {
"attributes": [
{
"id": "margin",
"type": "acme/dimensions",
"label": "Margin",
"sides": ["top", "bottom"],
"default": {
"top": "md",
"bottom": "md"
}
}
]
}
}
Valori normali dei template
Il valore salvato è disponibile in PHP, Twig e Blade come qualsiasi altro attributo Blockstudio.
<div class="<?php echo esc_attr('mt-' . ($a['margin']['top'] ?? '')); ?>">
<?php echo esc_html($a['title'] ?? ''); ?>
</div>
Gli stessi percorsi degli oggetti funzionano anche nei template delle estensioni:
{
"blockstudio": {
"extend": "core/group",
"attributes": [
{
"id": "margin",
"type": "acme/dimensions",
"set": [
{
"attribute": "class",
"value": "mt-{attributes.margin.top} mb-{attributes.margin.bottom}"
}
]
}
]
}
}
Note sulla compatibilità
I tipi di campo integrati esistenti non cambiano, così come i gruppi di campi riutilizzabili custom/{name} esistenti. I nomi dei tipi di campo personalizzati devono essere in minuscolo e avere un namespace, per esempio acme/dimensions; gli spazi dei nomi custom/ e blockstudio/ restano riservati.
Se PHP registra un tipo di campo ma il relativo script dell’editor non registra il controllo corrispondente, Blockstudio mantiene il valore salvato e mostra nell’editor un avviso non modificabile. Se un tipo di campo non è registrato in PHP, Blockstudio lo esclude dagli attributi WordPress generati.
Aggiornamento di manutenzione di 7.5.1
7.5.1 elimina un avviso di conversione da array a stringa che veniva emesso durante la preparazione per il rendering dei valori di selezione multipla. I valori salvati e renderizzati erano già corretti, ma i log di debug potevano ricevere un avviso per ogni rendering di campo.
Anche l’aggiornamento di blockstudio/phpstan v0.1.7 associato riconosce i campi annidati in gruppi anonimi in PHP, Twig, Blade e nelle strutture dedotte degli attributi dei template. I progetti esistenti possono ricevere questa correzione del pacchetto con composer update blockstudio/phpstan.