
Blockstudio 7 is er. Dit is de grootste release in de geschiedenis van het project: een volledige herschrijving van de hele codebase vanaf de basis. Elke klasse, elke hook en elke regel code is vanaf nul opnieuw opgebouwd, met aandacht voor moderne PHP, WordPress-codeerstandaarden en onderhoudbaarheid op lange termijn.

Maar dit is niet zomaar een refactor. Blockstudio 7 introduceert belangrijke nieuwe functies, zoals bestandgebaseerde pagina's en patronen, een opslagsysteem voor postmeta, integratie met SEO en een gloednieuwe parser van HTML naar blokken die dit alles mogelijk maakt. Bovendien is Blockstudio nu volledig gratis en opensource.

Laten we eens kijken naar alles wat nieuw is.

## Gratis en opensource

Ik werk al sinds 2020 aan Blockstudio en heb in de loop der jaren tientallen releases uitgebracht. De mensen die het gebruikten waren er enthousiast over, maar een geschikte markt vinden voor een commercieel WordPress-blokframework bleef altijd een uitdaging.

Wat de doorslag gaf, zijn LLM's. AI-codeerassistenten zijn nu goed genoeg om blokcode te schrijven, maar ze hebben daarvoor een overzichtelijke, bestandgebaseerde structuur nodig. De blokopmaak van WordPress is rommelig: geserialiseerde HTML-commentaren met ingesloten JSON-attributen, vermengd met DOM-structuur. Dat is lastig voor mensen en nog lastiger voor LLM's om goed te doen.

De bestandsgerichte aanpak van Blockstudio was altijd bedoeld om alles eenvoudig te houden: een `block.json` en een PHP-sjabloon in een map. Geen database-items, geen React, geen buildstap. Met v7 gaat die filosofie nog verder. Met de parser van HTML naar blokken kun je gewone HTML schrijven, die vervolgens automatisch wordt omgezet in geldige blokopmaak. Alles blijft in het bestandssysteem. De enige schrijfbewerkingen naar de database zijn paginasynchronisaties die expliciet worden aangevraagd via de PHP API of CLI; die worden aangestuurd door bestandssjablonen.

Blockstudio open source maken is de logische volgende stap. Hoe meer LLM's op Blockstudio-code trainen, hoe beter ze die kunnen genereren. Een open codebase, open documentatie en een vooraf samengesteld [AI-contextbestand](https://blockstudio.dev/nl/docs/dev/ai/) dat elke tool kan gebruiken: zo bouw je de beste omgeving voor AI-ondersteunde WordPressontwikkeling.

De volledige plugin is beschikbaar op
[GitHub](https://github.com/inline0/blockstudio) voor iedereen om te gebruiken, te forken en eraan bij te dragen. Geen licentiesleutels, geen betaalmuren, geen functiebeperkingen.

## Nieuwe functies

### Bestandgebaseerde pagina's

Dit is een van de grootste toevoegingen in 7.0. Je kunt nu volledige WordPress-pagina's definiëren als bestandssjablonen die met de databasesynchronisatie als native blokinhoud worden opgeslagen wanneer je de paginasynchronisatie API of CLI uitvoert.

Maak een map met een `page.json` en een sjabloonbestand:

```json title="page.json"
{
  "name": "about",
  "title": "About Us",
  "slug": "about",
  "postStatus": "publish"
}
```

```php title="index.php"
<div class="about-page">
  <h1>About Us</h1>
  <p>Welcome to our site.</p>
</div>
```

Voer `wp bs pages sync` uit om Blockstudio de HTML te laten parseren naar WordPress-blokken en de pagina in de database aan te maken of bij te werken.

#### Blokken samenvoegen op basis van sleutels

Bij het synchroniseren van sjablonen zouden gebruikersbewerkingen normaal gesproken worden overschreven. Het attribuut `key` voorkomt dit door gebruikersinhoud tussen synchronisaties te behouden:

```html title="index.php"
<h1 key="hero-title">Default Title</h1>
<p key="hero-description">Default description.</p>
```

Blokken met overeenkomende sleutels behouden hun door gebruikers bewerkte inhoud wanneer het sjabloon wordt bijgewerkt. Blokken zonder sleutels worden volledig vervangen.

#### Blokbindingen

Als alternatief voor sleutels kun je de WordPress-kernfunctie [Blokbindingen API](https://developer.wordpress.org/block-editor/reference-guides/block-api/block-bindings/) gebruiken om blokken rechtstreeks aan postmeta te koppelen. Dit is geen functie van Blockstudio, maar een native WordPress API. Blockstudio geeft het attribuut `metadata` simpelweg door aan de gegenereerde blokopmaak. De inhoud staat in de meta in plaats van in de blokopmaak, zodat gebruikersbewerkingen nooit verloren gaan bij sjabloonsynchronisaties. De gegevens zijn ook opvraagbaar via `WP_Query` en beschikbaar via de REST API.

```html title="index.php"
<h1 metadata='{"bindings":{"content":{"source":"core/post-meta","args":{"key":"hero_title"}}}}'>
  Default Title
</h1>
```

Beide methoden kunnen in hetzelfde sjabloon worden gebruikt.

#### Bewerkingsinstellingen

Voor pagina's kun je met `blockEditingMode` en `templateLock` instellen wat gebruikers mogen wijzigen:

```json title="page.json"
{
  "name": "landing",
  "title": "Landing Page",
  "blockEditingMode": "contentOnly",
  "templateLock": "all"
}
```

Hiermee wordt de pagin structuur vergrendeld, terwijl gebruikers wel tekst en media kunnen bewerken. Afzonderlijke elementen kunnen de instelling voor de hele pagina overschrijven met een attribuut `blockEditingMode` in het sjabloon.

#### Vastzetten op post-ID's

Gebruik `postId` om een paginasjabloon aan een bestaande WordPress-post te koppelen. Zo voorkom je dubbele pagina's en zorg je ervoor dat het sjabloon steeds de juiste post bijwerkt:

```json title="page.json"
{
  "name": "home",
  "title": "Home",
  "postId": 2
}
```

Zie voor alle details de [documentatie over pagina's](https://blockstudio.dev/nl/docs/pages-and-patterns/pages/).

### Bestandgebaseerde patronen

Net als bij pagina's kun je nu blokpatronen definiëren als bestandssjablonen. Schrijf je patroon in HTML. Blockstudio zet het om in blokopmaak en registreert het als een native WordPress-blokpatroon. Ze verschijnen in de blokinvoeger en gebruikers kunnen ze overal plaatsen.

```json title="pattern.json"
{
  "name": "hero-section",
  "title": "Hero Section",
  "categories": ["featured"],
  "keywords": ["hero", "banner"]
}
```

```html title="index.php"
<div class="hero">
  <h1>Welcome</h1>
  <p>Get started today.</p>
</div>
```

In tegenstelling tot pagina's maken patronen geen database-items aan. Ze worden bij elke paginaweergave in het geheugen geregistreerd. Zie de [documentatie over patronen](https://blockstudio.dev/nl/docs/pages-and-patterns/patterns/).

### Parser van HTML naar blokken

Pagina's en patronen worden beide aangedreven door een nieuwe HTML-parser die standaard-HTML-sjablonen omzet in WordPress-blokopmaak. De parser verwerkt automatisch containerblokken (zoals groepen en kolommen) en blokken zonder kinderen (zoals alinea's en koppen). De parser gebruikt een rendererarchitectuur op basis van traits, waardoor ondersteuning voor extra bloktypen eenvoudig kan worden toegevoegd via het filter `blockstudio/parser/renderers`:

```php title="functions.php"
add_filter( 'blockstudio/parser/renderers', function ( $renderers, $parser ) {
    $renderers['acme/hero'] = function ( $element, $attrs, $parser ) {
        $content = $parser->get_inner_html( $element );
        $html    = '<div class="acme-hero">' . $content . '</div>';

        return array(
            'blockName'    => 'acme/hero',
            'attrs'        => $attrs,
            'innerBlocks'  => array(),
            'innerHTML'    => $html,
            'innerContent' => array( $html ),
        );
    };

    return $renderers;
}, 10, 2 );
```

Na registratie kun je het blok in elk pagina- of patroonsjabloon gebruiken:

```html title="index.php"
<block name="acme/hero" background="/hero.jpg">
  <h1>Welcome to our site</h1>
</block>
```

### Opslag

Velden kunnen hun waarden nu opslaan in postmeta of site-opties, naast blokattributen. Dit is een belangrijke toevoeging:

```json title="block.json"
{
  "id": "subtitle",
  "type": "text",
  "label": "Subtitle",
  "storage": {
    "type": "postMeta"
  }
}
```

Met waarden in postmeta kun je:

- Berichten op veldwaarden opvragen met `WP_Query` en `meta_query`
- Veldgegevens opvragen via de REST API voor headless-configuraties
- Gegevens delen met andere plugins, zoals SEO-tools en cachinglagen

Je kunt waarden ook opslaan in de optietabel voor globale instellingen die voor de hele site gelden:

```json title="block.json"
{
  "id": "phone",
  "type": "text",
  "label": "Phone Number",
  "storage": {
    "type": "option",
    "optionKey": "company_phone"
  }
}
```

Zie de [documentatie over opslag](https://blockstudio.dev/nl/docs/blocks/storage/) voor de volledige API.

### Aangepaste velden

Herbruikbare velddefinities kunnen nu in meerdere blokken worden gedeeld. Definieer één keer een set velden en verwijs er vervolgens vanuit elk blok naar. Zo voorkom je herhaling wanneer meerdere blokken dezelfde veldstructuur gebruiken.

Maak een `field.json` aan in je blockstudio-map:

```json title="fields/hero/field.json"
{
  "name": "hero",
  "title": "Hero Section",
  "attributes": [
    { "id": "heading", "type": "text", "label": "Heading", "default": "Hello World" },
    { "id": "description", "type": "textarea", "label": "Description" }
  ]
}
```

Verwijs er vervolgens vanuit elk blok naar met het voorvoegsel `custom/`:

```json title="block.json"
{
  "blockstudio": {
    "attributes": [
      { "type": "custom/hero", "idStructure": "hero_{id}" }
    ]
  }
}
```

De eigenschap `idStructure` wordt vóór elke veld-ID geplaatst, dus `heading` wordt `hero_heading`. Je kunt afzonderlijke veldeigenschappen ook per instantie overschrijven met de sleutel `overrides`.

Zie de [documentatie over aangepaste velden](https://blockstudio.dev/nl/docs/blocks/attributes/custom-fields/).

### Tailwind CSS v4

De ondersteuning voor Tailwind is volledig vernieuwd voor v4. In plaats van client-side compilatie via CDN en opslag op schijf bij het opslaan van een post (de aanpak van v6), compileert Blockstudio 7 Tailwind server-side bij elk frontendverzoek via [TailwindPHP](https://github.com/dnnsjsk/tailwindphp). Geen Node.js, geen CLI en geen buildstap nodig.

De compilatie gebruikt caching op basis van kandidaten: Blockstudio haalt alle klassennamen van CSS op uit de uiteindelijke HTML, sorteert ze en berekent er samen met je CSS-configuratie een hash van. Vervolgens wordt gecontroleerd of er een bestand in de cache staat. Dezelfde klassen leveren dezelfde cachetreffer op, zelfs wanneer de omliggende HTML verandert (nonces, tijdstempels, dynamische inhoud).

De configuratie gebruikt de syntaxis van Tailwind v4, waarin CSS centraal staat. Definieer aangepaste thema's en utilityklassen rechtstreeks in je `blockstudio.json` of via het filter `blockstudio/tailwind/css`:

```php title="functions.php"
add_filter('blockstudio/tailwind/css', function ($css) {
  return $css . '
    @theme {
      --color-brand: #4f46e5;
    }

    @layer utilities {
      .container-narrow {
        max-width: 48rem;
        margin-inline: auto;
      }
    }
  ';
});
```

In de blokeditor biedt een meegeleverd Tailwind CDN-script een livevoorbeeld terwijl je typt. Het veldtype `classes` biedt automatisch aanvullen voor alle Tailwind-utilities. De frontend gebruikt altijd de servergecompileerde CSS, ingevoegd als een inline-stijltag vóór `</head>`.

Zie de documentatie over [Tailwind voor de volledige configuratie.](https://blockstudio.dev/nl/docs/tailwind/)

### Interactiviteit API

Blockstudio ondersteunt nu de [WordPress-interactiviteit API](https://developer.wordpress.org/block-editor/reference-guides/interactivity-api/). Schakel deze in je block.json in:

```json title="block.json"
{
  "blockstudio": {
    "interactivity": true
  }
}
```

Voeg `data-wp-*`-directieven toe aan je sjabloon:

```php title="index.php"
<div useBlockProps
     data-wp-interactive="myBlock"
     data-wp-context='{ "isOpen": false }'>
  <button data-wp-on--click="actions.toggle"
          data-wp-bind--aria-expanded="context.isOpen">
    Toggle
  </button>
  <div data-wp-bind--hidden="!context.isOpen">
    This content is toggled by the button.
  </div>
</div>
```

Maak vervolgens een `script.js` met de logica voor je store:

```javascript title="script.js"
import { store, getContext } from '@wordpress/interactivity';

store('myBlock', {
  actions: {
    toggle: () => {
      const context = getContext();
      context.isOpen = !context.isOpen;
    },
  },
});
```

Blockstudio regelt de importmap, het laden van modules en de verwerking van directieven, zowel op de frontend als in de blokeditor. Blokken die alleen declaratieve directieven met `data-wp-context` gebruiken (zoals `data-wp-bind--hidden` of `data-wp-text`), werken zonder JavaScript. Status aan de serverzijde via `wp_interactivity_state()` wordt ook ondersteund op de frontend.

Zie de [documentatie over interactiviteit](https://blockstudio.dev/nl/docs/blocks/interactivity/) voor de volledige configuratie.

### Analyse van SEO-inhoud

Blokken van Blockstudio zijn dynamisch, waardoor plugins voor SEO hun veldinhoud standaard niet kunnen zien. Blockstudio 7 lost dit op met automatische integraties voor Yoast SEO, Rank Math en SEOPress. Tekstwaarden uit de velden `text`, `textarea`, `richtext`, `wysiwyg` en `link` (inclusief geneste rijen van herhaalvelden) worden opgehaald en aan de inhoudsanalyse van elke plugin doorgegeven. Plugins voor SEO kunnen nu je blokinhoud correct analyseren op zoekwoorddichtheid, leesbaarheid en andere statistieken. Configuratie is niet nodig.

### Standaardrijen voor herhaalvelden

Herhaalvelden ondersteunen nu een eigenschap `default` met een array van vooraf ingevulde rijen. Wanneer een blok wordt ingevoegd, wordt het herhaalveld gevuld met de opgegeven rijen en hun waarden, zowel in de editor als op de frontend:

```json title="block.json"
{
  "id": "features",
  "type": "repeater",
  "label": "Features",
  "default": [
    { "title": "Fast", "icon": "bolt" },
    { "title": "Secure", "icon": "shield" }
  ],
  "attributes": [
    { "id": "title", "type": "text", "label": "Title" },
    { "id": "icon", "type": "text", "label": "Icon" }
  ]
}
```

De eigenschap `min` werkt ook met standaardwaarden op veldniveau: als een herhaalveld `min: 3` heeft en de onderliggende velden `default`-waarden hebben, worden de automatisch gegenereerde rijen met die standaardwaarden gevuld in plaats van leeg te blijven.

## Verbeteringen en oplossingen

- **Repeater `min` met veldstandaardwaarden**: automatisch gegenereerde minimumrijen gebruiken nu standaardwaarden op veldniveau, zowel op de frontend als in de editor
- **Tailwindeditorstijlen**: gecompileerde Tailwind CSS wordt nu in het iframe van de blokeditor geïnjecteerd, samen met de CDN, zodat aangepaste `@apply`-regels en thema-instellingen in de editor werken
- **[AI-contextbestand](https://blockstudio.dev/nl/docs/dev/ai/)**: de `blockstudio-llm.txt` is opnieuw opgebouwd als een statisch bestand, samengesteld uit de volledige documentatie van v7 en ontdubbelde JSON-schema's (~48k tokens), ter vervanging van de dynamische generatie vanuit v6
- **Codeveld in apart venster**: het codeveld kan nu in een apart venster worden geopend, met onafhankelijk ongedaan maken en opnieuw uitvoeren en JavaScript-syntaxmarkering
- **Tailwind v4 compilatie aan de serverkant**: zie de sectie [Tailwind](#tailwind-css-v4) hierboven
- **API versie 3**: blokken worden nu correct weergegeven in de editor in een iframe, inclusief de site-editor en responsieve voorbeelden
- **Puntnotatie voor assets**: overzichtelijkere bestandsnaamconventie voor assetsuffixen (`*.inline.css`, `*.editor.js`, `*.scoped.css`)
- Waarschuwing `bs_render_block()` van `WP_Block_Supports` verholpen bij gebruik van `useBlockProps`
- Voorwaardelijke velden respecteren nu standaardwaarden bij de eerste keer laden
- Dollartekens worden niet langer verwijderd uit `<RichText />`-inhoud op de frontend
- Functie `populate` werkt nu met taxonomieën die door andere plugins zijn geregistreerd
- Null-fout `optionsPopulate` in WPML-contexten verholpen

## Onder de motorkap

### Volledige herschrijving

Dit is geen refactor of opschoning. Elke klasse is vanaf nul herschreven. Het resultaat is een overzichtelijkere, meer modulaire codebase die eenvoudiger te onderhouden en uit te breiden is.

### Moderne PHP

Blockstudio 7 vereist PHP 8.2+ en gebruikt overal moderne typeaanduidingen.

## Incompatibele wijzigingen

Als grote versie-update bevat 7.0 verschillende wijzigingen die bestaande toepassingen kunnen breken. De meeste hebben achterwaarts compatibele terugvalopties, maar bekijk ze voordat je bijwerkt. Zie de [migratiedocumentatie voor v7](https://blockstudio.dev/nl/docs/dev/migration/v7/) voor de volledige migratiehandleiding.

### Hooknamen gebruiken nu snake_case

Alle PHP-hooks zijn hernoemd van camelCase naar snake_case, volgens de conventies van WordPress Core:

```php title="functions.php"
// Before (v6)
add_filter('blockstudio/settings/blockEditor/cssClasses', function() {
    return ['my-stylesheet'];
});

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

De oude namen in camelCase werken nog steeds, maar we raden aan ze bij te werken.

### Schakelaar voor velden staat standaard uit

De eigenschap `switch` heeft nu standaard de waarde `false` in plaats van `true`. In v6 had elk veld aan de linkerrand een onzichtbare schakelaar die standaard ingeschakeld was. In v7 is de schakelaar optioneel en wordt een zichtbaar oogpictogram in het veldlabel gebruikt. Als je op het standaardgedrag van de schakelaar vertrouwde, voeg dan `"switch": true` toe aan je velddefinities.

### Puntnotatie voor assetbestandsnamen

Achtervoegsels van assets gebruiken nu punten in plaats van streepjes (`style.inline.css` in plaats van `style-inline.css`). De oude notatie met streepjes werkt nog steeds, maar voortaan wordt puntnotatie aanbevolen.

### Voorvoegsel voor npm-imports

ES-module-imports gebruiken nu `npm:` in plaats van `blockstudio/`:

```javascript title="script.js"
// Before (v6)
import confetti from "blockstudio/canvas-confetti@1.6.0";

// After (v7)
import confetti from "npm:canvas-confetti@1.6.0";
```

Het voorvoegsel `blockstudio/` wordt nog ondersteund voor compatibiliteit met eerdere versies.

### Verwijderde functies

**Beheergedeelte en code-editor.** De WordPress-pagina met beheerinstellingen en de ingebouwde blokcode-editor zijn allebei verwijderd. Alle configuratie verloopt nu via de filters `blockstudio.json` en PHP, zodat je configuratie samen met je blokken in versiebeheer staat.

De code-editor was in eerdere versies handig om blokken te bekijken, maar bood nooit alle mogelijkheden van een echte ontwikkelomgeving. In de loop der jaren werden verschillende pluginfuncties achtergehouden omdat ze niet in de zelfstandige editor konden worden ondersteund. De editor zou ook nooit een volwaardige IDE vervangen. Door de editor te verwijderen, kan de plugin zich volledig richten op bestandgebaseerde ontwikkeling zonder compromissen.

**Licentiesleutel.** Niet langer nodig. Blockstudio is gratis en opensource.

**Blokbibliotheek.** De ingebouwde bibliotheek 'Blockstudio Elements' (Gallery, Slider, Image Comparison, Code, Icon) is verwijderd. Dit waren vooraf gebouwde voorbeeldblokken die met de plugin werden meegeleverd. Als je ze gebruikte, kopieer dan de blokmappen vanuit v6 naar de blockstudio-map van je thema.

## Aan de slag

Installeer Blockstudio 7 en maak binnen enkele minuten je eerste blok. Bekijk de [Handleiding om aan de slag te gaan](https://blockstudio.dev/nl/docs/general/getting-started/) voor stapsgewijze uitleg, of de [v7-migratiehandleiding](https://blockstudio.dev/nl/docs/dev/migration/v7/) als je een upgrade uitvoert vanaf v6.

De volledige broncode staat op [GitHub](https://github.com/inline0/blockstudio). Issues, PR’s en feedback zijn welkom.
