
Blockstudio 7.1 is de eerste functierelease sinds de herschrijving van v7. Waar v7 de basis opnieuw opbouwde, voegt 7.1 de onderdelen toe die blokken tot meer maken: een databaselaag, serverfuncties, geplande taken en een CLI. Een blokmap kan nu een complete applicatie zijn.

Dit is alles wat nieuw is.

## Componenten

Er is altijd een spanningsveld geweest tussen blokken die redacteurs in de invoeger gebruiken en blokken die ontwikkelaars als bouwstenen voor andere dingen gebruiken. Een kaart, een badge, een statistiekwidget, een formulierinvoer. Ze hebben de volledige Blockstudio-pijplijn nodig (attributen, sjablonen, assets, Tailwind), maar horen niet thuis in de invoeger.

7.1 introduceert componenten om dit op te lossen. Stel `"component": true` in je block.json in: het blok doorloopt dan de volledige buildpijplijn, maar wordt nooit geregistreerd in het bloktyperegister van WordPress. Het verschijnt niet in de invoeger en ook niet in de editorgegevens die naar JavaScript worden verzonden, maar is volledig beschikbaar voor programmatisch renderen.

```json title="block.json"
{
  "name": "my-theme/card",
  "title": "Card",
  "blockstudio": {
    "component": true,
    "attributes": [
      { "id": "title", "type": "text" },
      { "id": "description", "type": "textarea" }
    ]
  }
}
```

Render ze vanuit PHP:

```php
bs_render_block([
  'name' => 'my-theme/card',
  'data' => ['title' => 'My Card', 'description' => 'Card content.'],
]);
```

Of gebruik de nieuwe HTML-tagsyntaxis:

```html
<bs:my-theme-card title="My Card" description="Card content." />
```

## Bloktags

Blokken kunnen nu worden ingesloten als HTML-tags, met twee uitwisselbare syntaxisvarianten:

```html
<bs:acme-hero title="Welcome" />
<block name="acme/hero" title="Welcome" />
```

Beide leveren dezelfde uitvoer op. Beide werken met Blockstudio-blokken en kernblokken van WordPress. In bloksjablonen worden ze automatisch gerenderd, zonder dat je dit hoeft in te schakelen. Zo kun je complete lay-outs rechtstreeks in je sjabloon samenstellen uit andere blokken:

```twig title="index.twig"
<div class="my-page">
  <bs:mytheme-card title="Featured" />
  <block name="core/separator" />
  <bs:core-heading level="2">Section Title</bs:core-heading>
  <block name="core/group">
    <block name="core/paragraph">Inside a core group block.</block>
    <bs:mytheme-cta variant="primary" />
  </block>
</div>
```

De twee syntaxisvarianten kunnen vrij in elkaar worden genest. Blockstudio-blokken doorlopen de volledige pijplijn (sjablonen, Tailwind, assets). Kernblokken worden via WordPress gerenderd met dezelfde renderers als voor [Pagina's en patronen](https://blockstudio.dev/nl/docs/pages-and-patterns/).

Schakel dit in `blockstudio.json` in voor renderen op paginaniveau (berichtinhoud, widgetgebieden):

```json
{ "blockTags": { "enabled": true } }
```

Met toelatings- en blokkeerlijsten bepaal je via jokertekenpatronen welke blokken met tags mogen worden gerenderd. De attributen `data-*` en `html-*` worden doorgegeven aan het root-HTML-element van het gerenderde blok. Aangepaste renderers kunnen worden geregistreerd via het filter `blockstudio/block_tags/renderers`.

Onder de motorkap vervangt een nieuwe, lichte tekenscanner de volledige DOMDocument. De scanner verwerkt geneste tags met dieptetracking, recursieve containerblokken en gemengde syntaxis in één doorgang. In benchmarks parseert hij 1,000 vlakke tags in 2,4 ms en 100 niveaus van nesting in 3,7 ms, consequent sneller dan zowel DOMDocument als WordPress's `WP_HTML_Tag_Processor`. Dezelfde parser verwerkt ook ruwe HTML-elementen voor [Pagina's en patronen](https://blockstudio.dev/nl/docs/pages-and-patterns/). Daarmee vervangt hij de op DOMDocument gebaseerde parser die eerder `<p>`, `<div>` en andere HTML-elementen verwerkte.

## Nieuwe veldtypen

### Blok

Een nieuw veldtype `block` waarmee je naar een ander Blockstudio-blok kunt verwijzen als attribuut. De velden van het blok waarnaar wordt verwezen, worden inline uitgebreid met `idStructure` en `overrides`, precies zoals aangepaste velden. Het verschil: in het sjabloon geeft het opvragen van de waarde de gerenderde blokuitvoer terug.

```json title="block.json"
{
  "blockstudio": {
    "attributes": [
      {
        "id": "card",
        "type": "block",
        "block": "mytheme/card",
        "idStructure": "card_{id}"
      }
    ]
  }
}
```

Als `mytheme/card` velden `heading` en `content` heeft, krijgt het hostblok `card_heading` en `card_content` in de zijbalk. In het sjabloon geeft `{{ a.card }}` de gerenderde kaart weer. Werkt met zowel gewone blokken als componenten.

### Tag HTML

Elk thema heeft blokken waarvan het kopniveau afhankelijk van de context moet veranderen. Een H1 op de homepage, een H2 op subpagina's. In plaats van dit telkens op te lossen met een selectveld met hardgecodeerde opties, is er nu een speciaal veldtype `html-tag` met ingebouwde presets.

```json
{
  "id": "tag",
  "type": "html-tag",
  "default": "h2",
  "tags": "heading",
  "exclude": ["h5", "h6"]
}
```

Presets: `heading` (h1-h6), `text` (koppen + p, span, div), `structural` (div, section, article, aside, main, header, footer, nav), `all`. Je kunt ook een aangepaste array doorgeven. Met `exclude` verwijder je specifieke tags uit elke preset.

```twig
<{{ a.tag }}>{{ a.title }}</{{ a.tag }}>
```

## Database

Dit is het middelpunt van deze release. Voeg een bestand `db.php` toe aan een blokmap en Blockstudio genereert vijf REST-CRUD-eindpunten, valideert elke schrijfactie aan de hand van het schema, beheert de opslagbackend automatisch en biedt zowel een JavaScript-client (`bs.db()`) als een PHP API (`Db::get()`). Geen migratiebestanden, controllerklassen of routeregistratie nodig.

```php title="db.php"
return [
    'subscribers' => [
        'storage'    => 'table',
        'capability' => [
            'create' => true,
            'read'   => true,
            'update' => 'edit_posts',
            'delete' => 'manage_options',
        ],
        'fields' => [
            'email' => [
                'type'     => 'string',
                'format'   => 'email',
                'required' => true,
                'validate' => function ($value) {
                    if (str_ends_with($value, '@spam.com')) {
                        return 'This domain is blocked.';
                    }
                    return true;
                },
            ],
            'name' => ['type' => 'string', 'maxLength' => 100],
            'plan' => ['type' => 'string', 'enum' => ['free', 'pro']],
        ],
    ],
];
```

Dat schema alleen levert al een volledig werkende API op, met eindpunten voor maken, weergeven, ophalen, bijwerken en verwijderen, allemaal met invoervalidatie.

### Opslag

Vijf opslagbackends, elk geschikt voor verschillende toepassingen:

- **`table`**: Aangepaste MySQL-tabel beheerd via `dbDelta()`. Als u velden aan het schema toevoegt, worden bij de volgende keer dat de pagina wordt geladen kolommen toegevoegd. De standaard voor productie.
- **`sqlite`**: Eén SQLite-bestand in de map `db/` van het blok. Echte SQL-query's, WAL-modus voor gelijktijdige leesacties en volledig draagbaar. Kopieer de map, kopieer de database.
- **`jsonc`**: Eén JSON-object per regel in een plat bestand. Leesbaar voor mensen, versiebeheerbaar en geschikt voor git.
- **`meta`**: JSON-array in WordPress-postmeta, gekoppeld aan een specifieke post.
- **`post_type`**: Elk record wordt een WordPress-post in een aangepast posttype. Velden worden opgeslagen als afzonderlijke postmeta-items, volledig opvraagbaar met `WP_Query`.

### Clients

Aan de JavaScript-kant biedt `bs.db()` je een volledige CRUD-client:

```js
const db = bs.db('my-theme/block', 'subscribers');
const record = await db.create({ email: 'a@b.com', plan: 'pro' });
const pros = await db.list({ plan: 'pro' });
await db.update(record.id, { plan: 'free' });
await db.delete(record.id);
```

Er worden drie bijbehorende hulpprogramma's meegeleverd:

- **`bs.cache`**: cache voor query's in het geheugen met `get`, `set`, `invalidate` en `clear`. Gedeeld door alle query- en mutatieaanroepen.
- **`bs.query(key, fn, options)`**: voorziet elke asynchrone functie van caching, ontdubbeling van verzoeken en instelbare `staleTime`. Meerdere aanroepen met dezelfde sleutel terwijl een verzoek loopt, leveren dezelfde promise op.
- **`bs.mutate(options)`**: verwerkt optimistische mutaties met automatisch terugdraaien. Geef een reactief statusobject, een actie (`create`, `update`, `delete`) en optimistische gegevens door. De UI wordt direct bijgewerkt. Mislukt de serveraanroep, dan wordt de status teruggezet naar de momentopname van vóór de mutatie.

Samen dekken deze de volledige lees- en schrijfcyclus: `bs.query` voor gecachete lezingen, `bs.mutate` voor optimistische schrijfacties en `bs.cache` voor handmatige controle.

Aan de PHP-kant biedt de klasse `Db` dezelfde bewerkingen:

```php
use Blockstudio\Db;

$db = Db::get('my-theme/block', 'subscribers');
$db->create(['email' => 'a@b.com', 'plan' => 'pro']);
$db->list(['plan' => 'pro']);
```

### Validatie

Validatiefouten worden teruggestuurd als foutarrays per veld, geïnspireerd op de opmaak van `fieldErrors` van Zod. Meerdere regels kunnen voor hetzelfde veld mislukken. Dankzij de structuur kun je fouten eenvoudig koppelen aan formuliervelden aan de frontend:

```json
{
  "data": {
    "status": 400,
    "errors": {
      "email": ["Must be a valid email address.", "This domain is blocked."],
      "plan": ["Must be one of: free, pro."]
    }
  }
}
```

Aangepaste callbacks `validate` worden server-side uitgevoerd voor alles wat de ingebouwde regels niet afdekken: domeinen blokkeren, velden onderling valideren en externe gegevens opvragen.

### Gebruikersgebonden gegevens

Stel `userScoped` in op `true` voor gegevens per gebruiker, zoals taken, favorieten of concepten; Blockstudio regelt de rest. Het voegt een kolom `user_id` toe, vult die automatisch in bij het aanmaken en filtert elke query op de huidige gebruiker. Bijwerken en verwijderen controleren het eigenaarschap. Geen handmatig veld `user_id`, geen hook `before_create` en geen filtering in RPC. Eén configuratieregel. Bij gebruik van opslag `post_type` wordt `userScoped` gekoppeld aan `post_author` in plaats van aan een aparte kolom.

```php
return [
    'storage'    => 'sqlite',
    'userScoped' => true,
    'fields'     => [ /* ... */ ],
];
```

### Realtime pollen

Stel `'realtime' => true` in je schema in en de client controleert automatisch op wijzigingen. Verandert er iets op de server, dan wordt de Interactivity API-store bijgewerkt en rendert UI opnieuw, zonder dat je zelf JavaScript hoeft aan te passen. Configureer dit met `'realtime' => ['key' => 'todos', 'interval' => 5000]` voor aangepaste statussleutels en intervallen. Bij het pollen worden hashes vergeleken om verzoeken licht te houden; het pollen pauzeert wanneer het browsertabblad verborgen is.

### Beveiliging, hooks en overdraagbaarheid

Openbare eindpunten worden beveiligd met een automatisch ingevoegde CSRF-header `X-BS-Token`. Gebruik `'open'` wanneer je toegang zonder authenticatie nodig hebt, bijvoorbeeld voor inkomende webhooks.

Levenscyclushooks worden uitgevoerd vóór en na elke schrijfactie. Definieer ze inline in `db.php` of globaal via acties WordPress.

Velden kunnen een `component`-sleutel definiëren voor formulierweergave op basis van het schema via `bs_db_form()`.

Met opslag SQLite of JSONC staat de volledige applicatie in één map: de code, de logica, de toegangscontrole en de gegevens. Kopieer de map om de applicatie te implementeren.

## RPC

Soms is CRUD niet genoeg. Je hebt aangepaste serverlogica nodig: een taak omschakelen, een melding versturen of statistieken verzamelen. Daarvoor is `rpc.php` bedoeld. Definieer een functie PHP, roep die vanaf de frontend aan met `bs.fn()` en Blockstudio regelt het eindpunt REST, de authenticatie, CSRF-beveiliging en JSON-serialisatie. Het patroon is geïnspireerd op [tRPC](https://trpc.io): procedures worden server-side gedefinieerd en vanaf de client op naam aangeroepen.

```php title="rpc.php"
return [
    'subscribe' => function (array $params): array {
        $email = sanitize_email($params['email']);
        return ['success' => true];
    },
];
```

```js
const result = await bs.fn('subscribe', { email: 'user@example.com' });
```

Inline scripts (`script-inline.js`) leiden de bloknaam automatisch af uit het attribuut `data-block` op hun scripttag, zodat je die niet handmatig hoeft door te geven. Modulescripts geven de naam mee als derde argument.

Opties voor toegangscontrole zijn onder meer `public` (met CSRF), `'open'` (zonder bescherming), capability-strings of arrays. Controle van de HTTP-methode per functie, levenscyclushooks en aanroepen tussen blokken vanuit zowel JS als PHP worden ondersteund.

## Cron

Achtergrondtaken worden gedefinieerd in een bestand `cron.php`. Stel een planning en callback in; Blockstudio registreert ze bij het initialiseren in WordPress Cron. Wanneer de plugin wordt gedeactiveerd, worden alle taken netjes uit de planning verwijderd.

```php title="cron.php"
return [
    'cleanup' => [
        'schedule' => 'daily',
        'callback' => function () {
            $db = Db::get('my-theme/app', 'logs');
            // delete old entries
        },
    ],
    'sync' => [
        'schedule' => 'hourly',
        'callback' => function () {
            // pull from external API
        },
    ],
];
```

Alle ingebouwde WordPress-planningen worden ondersteund, evenals aangepaste intervallen via het filter `cron_schedules`.

## CLI

Een nieuwe opdracht `wp bs` omvat de volledige functieset van Blockstudio: blokken, database, RPC, cron, instellingen, compilatie van Tailwind, compilatie van SCSS, aangepaste velden en assetbeheer.

```bash
wp bs blocks list --components
wp bs db schemas
wp bs db create my-theme/app subs --email=a@b.com
wp bs db list my-theme/app subs --plan=pro --format=json
wp bs rpc call my-theme/app subscribe --email=a@b.com
wp bs cron run my-theme/app cleanup
wp bs tailwind compile --file=template.html
wp bs scss compile --file=style.scss
wp bs fields list
wp bs assets list --type=global
wp bs settings get tailwind/enabled
```

Alle opdrachten ondersteunen `--format=json` voor scripts.

## Verbeteringen aan Repeatervelden

### textMinimized voor objectvelden

Ingeklapte rijen van repeatervelden verwerken objectveldwaarden nu correct. Eerder toonde `textMinimized` bij een linkveld `[object Object]`. Nu leest Blockstudio automatisch de juiste subeigenschap op basis van het veldtype: `title` voor links, `value` voor kleuren en kleurverlopen, en `icon` voor pictogrammen. Je kunt ook een expliciete eigenschap `key` instellen om elke gewenste subeigenschap uit te lezen.

```json
{
  "type": "repeater",
  "textMinimized": { "id": "href", "fallback": "Add a link" },
  "attributes": [{ "id": "href", "type": "link" }]
}
```

### RichText en MediaPlaceholder

Beide sjablooncomponenten werken nu binnen repeatervelden, met haakjesnotatie om de juiste rij aan te spreken. Zo kun je in elke rij van een repeaterveld koppen, alinea's en media-uploadzones inline bewerken.

```twig
{% for item in a.items %}
  <div class="card">
    <MediaPlaceholder attribute="items[{{ loop.index0 }}].image" />
    <RichText tag="h2" attribute="items[{{ loop.index0 }}].heading" />
    <RichText tag="p" attribute="items[{{ loop.index0 }}].content" />
  </div>
{% endfor %}
```

## Voorwaarden voor aangepaste velden met idStructure

Bij gebruik van een aangepast veld met `idStructure` worden de ID's van voorwaarden in de velddefinitie nu automatisch aangepast aan de uitgebreide namen. Als je veldgroep voor tekengrootte een voorwaarde op `enable` heeft en je die uitbreidt met `idStructure: "title_font_{id}"`, verwijst de voorwaarde nu correct naar `title_font_enable` in plaats van naar het oorspronkelijke `enable`.

Ook voorwaarden op referentieniveau worden ondersteund. Voeg `conditions` toe aan de verwijzing naar het aangepaste veld om ze in één keer toe te passen op elk uitgebreid veld.

## Dynamische vulargumenten

Vulargumenten kunnen nu met de syntaxis `{attributes.*}` verwijzen naar andere blokattributen. Wanneer het attribuut waarnaar wordt verwezen verandert, haalt het selectveld automatisch nieuwe opties op. Koppel selectvelden aan elkaar: één om een berichttype te kiezen, een ander om berichten van dat type te laden.

```json
{
  "id": "selected_post",
  "type": "select",
  "populate": {
    "type": "query",
    "query": "posts",
    "arguments": {
      "post_type": "{attributes.post_type}"
    }
  }
}
```

Wijzig `post_type` in "page" en het tweede selectveld laadt pagina's. Wijzig het in "post" en het laadt berichten. Werkt met elk vultype en elk attribuut.

## Composer

Blockstudio werkt nu wanneer het vanuit elke map onder `wp-content/` wordt geladen, niet alleen vanuit de plug-insmap. Asset-URL's worden opgelost met een constante `BLOCKSTUDIO_URL` in plaats van `plugins_url()`, zodat installaties die in thema's zijn opgenomen direct werken:

```php title="functions.php"
require_once __DIR__ . '/vendor/autoload.php';
require_once __DIR__ . '/vendor/blockstudio/blockstudio/blockstudio.php';
```

De runtime-afhankelijkheden van `composer.json` zijn opgeschoond. Scoped packages (TailwindPHP, ScssPhp, Minify) die al in `lib/` zijn gebundeld, staan niet langer in de runtime-afhankelijkheden. Alleen `php >= 8.2` en `plugin-update-checker` blijven over.

Alle drie installatiemethoden (plug-in-zip, plug-in via Composer, in thema opgenomen via Composer) starten met hetzelfde resultaat: volledige activering van WordPress, blokregistratie en frontendweergave.

Raadpleeg de documentatie van [Composer](https://blockstudio.dev/nl/docs/dev/composer/) voor installatie-instructies.

## Prestatieprofiler

Voeg `?blockstudio-perf` toe aan de URL van een pagina en onderaan verschijnt een debugpaneel met rendertijden per blok, uitsplitsingen per fase en cachehitpercentages. Timinggegevens worden ook als Server-Timing-headers verzonden en zijn zichtbaar op het tabblad Network van de browser-DevTools.

```json title="blockstudio.json"
{ "dev": { "perf": true } }
```

Schakel dit permanent in via de instellingen om elke paginalading te profileren. Alleen zichtbaar voor ingelogde gebruikers met de capability `edit_posts`.

Bloktags zonder sluiting worden nu ook in het geheugen gecachet. Wanneer hetzelfde blok met identieke attributen meerdere keren op een pagina voorkomt, slaan latere renderingen de volledige sjabloonpijplijn over.

## Opgeloste bugs

- **PHP 8.4-waarschuwingen voor afgeschreven functies**: waarschuwingen voor afgeschreven functies van `strpos()` en `str_replace()` zijn opgelost. Ze werden veroorzaakt doordat `null` werd doorgegeven aan `add_submenu_page()`.

## Meer

- **Codevelden SCSS**: codevelden ondersteunen `language: "scss"`. Waarden worden zowel in de editor als op de frontend gecompileerd via ScssPhp.
- **Standaardblokken WordPress**: mappen Blockstudio kunnen naast blokken Blockstudio ook uitvoer `@wordpress/create-block` bevatten. Ze worden automatisch geregistreerd, zonder aparte plug-incode.

---

Als je het full-stackpatroon in de praktijk wilt zien, laat de gids [Full-Stackblokken](https://blockstudio.dev/nl/guides/full-stack-blocks/) zien hoe je vanaf nul een takenapp voor gebruikers en een openbare aanmelding voor een nieuwsbrief bouwt.
