Dennis · 23 juli 2026
Blockstudio 7.5
Blockstudio 7.5 rondt de bestandsgerichte workflow van Blockstudio af met aangepaste veldtypen, Site Editor-templates op basis van bestanden, block-eilandjes, Storh-databaseopslag, logische ontdekkingsbronnen, combineerbare blocktags en snellere deploy- en runtimepaden.
Met herbruikbare aangepaste velden kunnen projecten al een groep bestaande velden eenmalig definiëren en hergebruiken met type: "custom/{name}". Aangepaste veldtypen lossen een ander probleem op. Hiermee kunnen een thema of plugin een nieuw veldtype met een eigen namespace registreren, er een eigen editorbesturingselement voor aanbieden en de waarde opslaan als gewone Blockstudio-gegevens.
In het kort:
- Logische ontdekkingsbronnen: runtimes kunnen een samengestelde logische themainventaris aanleveren, inclusief herkomst en cache-identiteit, terwijl Blockstudio verantwoordelijk blijft voor ontdekking, het oplossen van verwante bestanden, gegenereerde assets, Canvas en Tailwind-gedrag.
- PHP-veldtyperegister: thema’s en plugins kunnen veldtypen met een namespace registreren, zoals
acme/dimensionsmetbs_register_field_type()of het filterblockstudio/field_types. - Register voor editorbesturingselementen: aangepaste editorscripts kunnen
window.blockstudio.registerFieldType()aanroepen en het bijbehorende besturingselement React weergeven in het normale Blockstudio-veld UI. - Gestructureerde waarden: aangepaste velden kunnen tekenreeksen, getallen, booleans, arrays of objecten opslaan zonder objectwaarden via de normalisatie van optievelden om te zetten.
- Ondersteuning voor opslag: aangepaste velden op basis van postmeta en opties kunnen hun waardetype en REST-schema declareren, inclusief object- en arraywaarden.
- Native integratie: aangepaste veldtypen werken in groepen, tabbladen, herhalers, herbruikbare aangepaste velden, templates en paden voor uitbreidingstemplates.
- Site Editor-templates: thema’s kunnen
wp_template– enwp_template_part-bronnen definiëren op basis vantemplate.json-,part.json– en Blockstudio-templatebestanden. - Blokeilanden: blokken kunnen eerst een cacheveilige basis weergeven en daarna fragmentspecifieke gegevens laden of in batches ophalen nadat de pagina is geladen.
- Storh-databaseopslag:
bs.dbkan een geïndexeerde opslag met één bestand per record in uploads gebruiken, waarbij openbare integer-ID’s behouden blijven en migratie van JSONC naar Storh via WP-CLI verloopt. - Verbeteringen aan parser en bsui: voor alinea’s met toegewezen richtext is minder aangepaste parsercode nodig,
InnerBlockskan getokeniseerdeallowedBlocksgebruiken, geneste uitvoer vanbs_render_block()komt in editorvoorbeelden overeen met de frontendweergave, enbsui/buttonbiedt pictogrammen en eenvoudigere stijlopties. - Combineerbare bloktags: voorvoegsel-tags kunnen via een ander voorvoegsel worden opgelost (
<theme-ui-input>naarbsui/input), en voorvoegsel- en aliastags worden weergegeven in de uitvoer van bloktemplates, niet alleen in pagina-inhoud. - Buildcaches die hosts ontzien: runtime- en editorcaches staan standaard buiten uploads, ondersteunen instelbare locaties en verwijderen verouderde items, zodat langlopende projecten geen cachebestanden opstapelen.
- Incrementele paginaverwerking: implementatietools kunnen de volledige inventaris van bestandspagina’s verwerken, ongewijzigde berichten overslaan, precies rapporteren wat is gewijzigd en na activering een geverifieerde bronidentiteit opslaan.
- Snellere weergave bij een warme cache: geldige runtimecaches worden vóór ontdekking geladen, gelijktijdige verzoeken zonder cache publiceren één atomair resultaat en Tailwind houdt een cache op siteschaal bij met herbruikbare compilerstatus.
- Veilige batchweergave: exporteurs kunnen de verzoekspecifieke weergavestatus tussen documenten opnieuw instellen zonder ontdekking opnieuw op te bouwen en kunnen bronafhankelijkheden verzamelen terwijl blokken worden weergegeven.
Nieuwe functies
Versie 7.5 introduceert een breed scala aan nieuwe mogelijkheden voor ontdekking, templates en opslag.
Logische ontdekkingsbronnen
Blockstudio ontdekt normaal gesproken bestanden in fysieke themamappen. Versie 7.5 voegt een bron op lager niveau toe, API, voor runtimes die een thema samenstellen uit overlays, voorbeelden, gegenereerde bestanden, externe koppelingen of andere samengestelde inventarissen.
Een integratie kan een definitieve logische bestandsstructuur aanleveren, terwijl Blockstudio verantwoordelijk blijft voor blokken, velden, pagina’s, patronen, Site Editor, Canvas, assets en Tailwind-gedrag:
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
);
Logische paden blijven stabiel, zelfs wanneer verwante bestanden uit verschillende fysieke locaties komen. Bron-ID’s en fingerprints bepalen de runtime- en Tailwind-cache-identiteiten; wijzigingen in bewaakte invoerbestanden maken die caches ongeldig en de herkomst bepaalt waar gegenereerde bestanden mogen worden geschreven. De standaardbron voor het bestandssysteem blijft ongewijzigd voor normale thema’s.
Site Editor-templates op basis van bestanden
Teams kunnen inhoudsstructuren al in bestanden bewaren voor pagina’s en patronen. Versie 7.5 breidt dat model uit naar de Site Editor zelf.
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 compileert de bron met dezelfde parser als voor pagina’s en patronen en biedt het resultaat vervolgens aan WordPress aan als een normale Site Editor-template of template-onderdeel. De Site Editor ziet de template, de frontend kan die weergeven en WordPress beheert nog steeds aanpassingen.
Dat laatste is belangrijk. Templates op basis van bestanden dienen als terugvalbron. Als een gebruiker een template opslaat in de Site Editor, maakt WordPress de gebruikelijke aanpassing in de database als wp_template of wp_template_part; die versie krijgt voorrang. Zet de aanpassing terug en de nieuwste bestandsbron wordt weer zichtbaar.
Incrementele paginadeployments
Bestandspagina’s kregen in versie 7.5 een reconciliatie-API voor deployments. Sinds 7.6.2 zijn die expliciete API en wp bs pages sync de enige toegangspunten voor synchronisatie; gewone verzoeken passen geen bronwijzigingen toe:
$report = Blockstudio\Pages::reconcile([
'authoritative' => true,
'plan_valid' => true,
'source' => [
'commit' => $commit,
'dirtyHash' => $dirtyHash,
],
]);
De verwerking ontdekt de volledige gewenste pagina-inventaris, vergelijkt inhoud en fingerprints van de sync-engine en rapporteert aangemaakte, bijgewerkte, ongewijzigde, verwijderde en mislukte pagina’s. Bij pagina’s met gelijke fingerprints worden geen post- of postmeta-gegevens geschreven. Ontbrekende beheerde pagina’s worden alleen verwijderd als de ontdekking zonder fouten is voltooid.
Reconciliatie retourneert een deterministische bronidentiteit, maar markeert een deployment niet als geslaagd. Deploymenttools slaan die identiteit pas op nadat de bijbehorende bestanden en routes actief en geverifieerd zijn. Bij de gewone bootstrap van WP-CLI worden gecachete verzameling-posttypen en rewrite-regels geregistreerd, zonder elke pagina te ontdekken en te synchroniseren.
Blokeilanden
De meeste Blockstudio-blokken worden op de server weergegeven. Dat past goed bij WordPress, maar veroorzaakt een bekend cacheprobleem: één gepersonaliseerd blok kan het lastig maken om de hele pagina in de cache op te slaan.
Blokeilanden verleggen die grens naar het niveau van afzonderlijke blokken.
{
"name": "acme/cart-count",
"blockstudio": {
"island": "dynamic"
}
}
Een dynamisch eiland geeft in het eerste antwoord alleen een cacheveilige tijdelijke aanduiding weer. De browser stuurt vervolgens één gebundeld verzoek voor alle dynamische eilanden die klaar zijn op de pagina, waarna Blockstudio die fragments weergeeft in de echte verzoekcontext van de bezoeker.
Zo kan een volledige paginacache de paginaschil opslaan, terwijl het aantal winkelwagenitems, accountbedieningselementen, toegangsbeperkte UI-onderdelen en andere gebruikersspecifieke delen actueel blijven.
<div class="cart-count-placeholder">Loading cart...</div>
<div class="cart-count">
<?php echo esc_html(acme_cart_count()); ?>
</div>
Gebruik voor blokken die al cacheveilige HTML weergeven en alleen een mountsignaal voor de frontend nodig hebben een gehydrateerd eiland:
{
"name": "acme/tabs",
"blockstudio": {
"island": "hydrate"
}
}
Gehydrateerde eilanden doen geen REST-verzoek. Ze worden normaal weergegeven en ontvangen op de frontend een blockstudio:island:hydrate-gebeurtenis.
Dynamische eilanden werken ook via de programmatische weergavepaden:
bs_render_block([
'name' => 'acme/cart-count',
'data' => ['productId' => 42],
]);
En via bloktags:
<bs:acme-cart-count product-id="42" />
Het eindpunt is bewust beperkt. Het geeft alleen geregistreerde Blockstudio-blokken weer die dynamisch zijn en expliciet als dynamisch eiland zijn gemarkeerd. Attributen worden gefilterd op basis van het blokschema en de toestemmingslijst van het eiland, en elke markering bevat een handtekening die is gegenereerd door de serverende WordPress-site.
Storh-databaseopslag
De databaselaag van Blockstudio ondersteunt al tabellen, SQLite, JSONC, postmeta en aangepaste posttypen. Versie 7.5 voegt storage: "storh" toe voor projecten die een bestandsgebaseerde opslag willen met veiligere gelijktijdige schrijfbewerkingen en schema-afgeleide indexen, maar geen live records naast bronbestanden van blokken willen vastleggen.
return [
'storage' => 'storh',
'fields' => [
'title' => ['type' => 'string', 'required' => true],
'status' => ['type' => 'string'],
'count' => ['type' => 'integer'],
],
];
Storh-records worden opgeslagen in uploads:
wp-content/uploads/blockstudio/db/my-theme-my-block/default/
De openbare API blijft ongewijzigd. bs.db(), REST en Db::get() retourneren nog steeds integerwaarden van id. Intern koppelt Blockstudio die ID’s aan de document-ID’s van Storh met UUIDv7, zodat bestaande clientcode niet hoeft te veranderen.
Elk gedeclareerd schema-veld wordt geïndexeerd voor filters op gelijkheid. Numerieke en datumachtige velden krijgen bereikindexen en expliciete unieke hints worden doorgegeven. Voor projecten die zijn begonnen met JSONC-seedbestanden behoudt de nieuwe migratie van CLI het bronbestand op zijn plaats en schrijft deze een gelijkwaardige Storh-opslag:
wp bs db migrate my-theme/app subscribers --to=storh
Zo krijgt JSONC een duidelijkere rol als eenvoudig seed- en configuratieformaat dat in versiebeheer kan worden vastgelegd, terwijl Storh de betere standaardbestandsbackend wordt voor beschrijfbare productiegegevens.
Verbeteringen aan parser en bsui
Versie 7.5 werkt ook kleinere onderdelen bij die vaak nodig zijn zodra een project meer gebruikmaakt van templates op basis van bestanden en gebundelde UI.
Elementtoewijzing kan nu het gebruikelijke geval van een richtext-alinea afhandelen zonder aangepaste builder. Als <p> wordt toegewezen aan een geregistreerd blok van Blockstudio dat geen kernblok is en een richtext-attribuut content heeft, wordt eenvoudige binnentekst naar dat attribuut gekopieerd. Geneste tags en toegewezen onderliggende elementen worden nog steeds als binnenblokken geparseerd.
InnerBlocks accepteert getokeniseerde allowedBlocks in templates:
<InnerBlocks allowedBlocks="<?php echo esc_attr(wp_json_encode([
'core/paragraph',
'category:content',
'bsui/field',
])); ?>" />
De ondersteunde tokens zijn namespace/*, category:<slug> en @theme. Ze worden op de server uitgebreid voordat de template de editor bereikt, zodat het weergavepad voor de frontend ongewijzigd blijft.
Programmatic embeds zijn ook voorspelbaarder. bs_render_block() en bs_block() geven ingesloten blokken nu weer als HTML die door de frontend worden opgelost, zelfs wanneer ze vanuit de editorvoorvertoning van een ander blok worden aangeroepen. Daardoor lekken geneste blokken geen ruwe <RichText />– of <InnerBlocks />-pseudocomponenten in de preview-markup.
Voor gebundelde UI ondersteunt bsui/button nu een attribuut icon en iconPosition. Inline stijlen van gebundelde bsui/* worden uitgegeven in een @layer bsui-cascadelaag en knopvarianten kunnen worden uitgebreid met blockstudio/ui/button/variants-style en het bestaande filter blockstudio/blocks/attributes.
Bloktags zijn nu nog beter te combineren. Een voorvoegsel kan via een ander voorvoegsel worden opgelost, zodat <theme-ui-input /> met projectvoorvoegsel theme binnen namespacevoorvoegsel ui wordt opgelost als bsui/input. Geregistreerde voorvoegsel- en aliastags worden nu ook weergegeven in de uitvoer van bloktemplates, niet alleen in pagina-inhoud; een template kan ze dus rechtstreeks uitvoeren in plaats van bs_render_block() aan te roepen.
Aangepaste blokbuilders die via blockstudio/block_tags/builders zijn geregistreerd, worden nu ook consistent gebruikt bij het parsen van tags en toegewezen elementen. Expliciete renderfilters worden daarna nog steeds uitgevoerd en kunnen de builder overschrijven.
Snellere warme verzoeken en exports
De runtime- en editorcaches staan standaard nu in wp-content/blockstudio/cache in plaats van uploads. De locatie kan worden gewijzigd via cache.path of blockstudio/cache/dir, zodat persistente caching beschikbaar blijft op hosts die PHP-payloads in uploads blokkeren. Runtime-, editorasset- en Tailwind-caches verwijderen ook automatisch verouderde items, zodat langlopende projecten geen onbeperkte hoeveelheid cachebestanden op schijf opstapelen.
Warme frontendverzoeken laden nu een geldige runtime-registry voordat ze ontdekkingsbronnen aanmaken. Zo worden recursieve bronontdekking, blokconstructie, veldparsing en herhaalde boomdoorlopen voor cachekeys overgeslagen. Verzoeken uit productie- en stagingomgevingen vertrouwen standaard 20 seconden op een gevalideerde momentopname van bewaakte invoerbestanden, terwijl lokale en ontwikkelomgevingen bij elk verzoek blijven controleren.
Het aanmaken van een koude cache verloopt als één gedeelde taak. Eén verzoek bouwt de payload en publiceert die atomair, terwijl gelijktijdige verzoeken wachten op het voltooide resultaat. Tailwind bewaart nu standaard maximaal 1,000 gecompileerde items gedurende 30 dagen en hergebruikt de opbouwstatus van een warme compiler, zodat een routeverzameling op siteschaal niet voortdurend door een kleine cache rouleert.
Exporteurs die lang actief blijven, kunnen tussen documenten Blockstudio\Batch_Render::reset() aanroepen. Hiermee worden verzoekspecifieke tellers, assets, eilanden, lay-outs en de generatie van Tailwind gewist zonder de ontdekking opnieuw op te bouwen. Het filter blockstudio/render/dependencies geeft de template- en assetpaden vrij die door elk weergegeven blok zijn gebruikt, voor afhankelijkheidsgrafieken.
Betrouwbaarheid en compatibiliteit
Enkele oplossingen maken de release compleet:
- Velddefinities die zijn gewijzigd via
blockstudio/blocks/attributessturen nu zowel de validatie van opties tijdens het renderen als het editorschema aan. Typwaarden voor numerieke en booleaanse opties worden ook consistent verwerkt. - Editorblokwrappers gebruiken dezelfde gegenereerde klassen als frontendweergaven, en Canvas kan via het nieuwe filter
blockstudio/editor/canvas/body_classde geconfigureerde bodyklassen van de frontend overnemen. - Content Sync valideert het volledige bronplan voordat er destructieve schrijfbewerkingen plaatsvinden, houdt opschoningsbewerkingen binnen de geconfigureerde inhoudsset en meldt schrijffouten in bestanden zonder de synchronisatiestatus van die entiteit bij te werken.
- Composer-pakketten in symlinkte actieve thema’s of bovenliggende thema’s halen editorassets nu op uit de openbare URL van het thema.
- Bestandspagina’s met een sleutel behouden veldwaarden die door de editor worden beheerd via Blockstudio, zetten bij synchronisatie de oudere geneste sleutelstructuur om en accepteren numerieke nul als geldige sleutel.
- Dynamische islands controleren handtekeningen voordat request-attribuutfilters worden toegepast, negeren niet-ondertekende requestcontext, herstellen ingelogde bezoekers van dezelfde oorsprong en voorkomen anonieme cachebotsingen per gebruiker.
- Raw Markdown-pagina-eindpunten houden nu rekening met de zichtbaarheid van berichten en wachtwoordbeveiliging.
- Editorbedieningselementen verwerken lege voorwaarden, waarden voor ‘alles selecteren’ bij selectievakjes, asynchrone updates van opties, de volgorde van dynamische rendering en de RichText- of WYSIWYG-status van repeaters betrouwbaarder.
Aangepaste veldtypen
Meer informatie over de hierboven geïntroduceerde aangepaste veldtypen.
Waarom aangepaste veldtypen?
Blockstudio moet direct bruikbaar blijven, maar echte projecten hebben vaak domeinspecifieke bedieningselementen nodig: kiezers voor afstandstokens, kleurrollen van een designsysteem, responsieve afmetingen, pictogrambronnen, productkiezers of redactionele bedieningselementen die een gestructureerde waarde opleveren.
Vóór versie 7.5 konden zulke projecten meerdere ingebouwde velden combineren of de editor aanpassen. Versie 7.5 biedt een ondersteunde middenweg: Blockstudio beheert de levenscyclus van het veld en het project beheert het bedieningselement.
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,
});
},
}),
),
);
},
});
Daarna kan het veld in block.json worden gebruikt als een native veld:
{
"blockstudio": {
"attributes": [
{
"id": "margin",
"type": "acme/dimensions",
"label": "Margin",
"sides": ["top", "bottom"],
"default": {
"top": "md",
"bottom": "md"
}
}
]
}
}
Normale templatewaarden
De opgeslagen waarde is beschikbaar in PHP, Twig en Blade, net als elk ander attribuut van Blockstudio.
<div class="<?php echo esc_attr('mt-' . ($a['margin']['top'] ?? '')); ?>">
<?php echo esc_html($a['title'] ?? ''); ?>
</div>
Dezelfde objectpaden werken ook in uitbreidingstemplates:
{
"blockstudio": {
"extend": "core/group",
"attributes": [
{
"id": "margin",
"type": "acme/dimensions",
"set": [
{
"attribute": "class",
"value": "mt-{attributes.margin.top} mb-{attributes.margin.bottom}"
}
]
}
]
}
}
Compatibiliteitsnotities
Bestaande ingebouwde veldtypen blijven ongewijzigd. Ook bestaande herbruikbare veldgroepen van custom/{name} blijven ongewijzigd. Namen van aangepaste veldtypen moeten kleine letters bevatten en een namespace hebben, bijvoorbeeld acme/dimensions; de namespaces custom/ en blockstudio/ blijven gereserveerd.
Als PHP een veldtype registreert, maar het editorscript het bijbehorende bedieningselement niet registreert, behoudt Blockstudio de opgeslagen waarde en toont het een niet-bewerkbare melding in de editor. Als een veldtype niet is geregistreerd in PHP, laat Blockstudio het weg uit gegenereerde attributen van WordPress.
Onderhoudsupdate voor 7.5.1
7.5.1 verhelpt een waarschuwing over het omzetten van een array naar een tekenreeks die werd gegeven bij het voorbereiden van meerdere selectieopties voor weergave. De opgeslagen en weergegeven waarden waren al correct, maar debuglogs konden bij elke veldweergave één waarschuwing bevatten.
De bijbehorende update van blockstudio/phpstan v0.1.7 herkent ook velden die binnen anonieme groepen zijn genest in PHP, Twig, Blade en afgeleide templatestructuren van attributen. Bestaande projecten kunnen deze pakketoplossing ontvangen met composer update blockstudio/phpstan.