
Blockstudio 7.1 er den første funktionsudgivelse siden omskrivningen af v7. Hvor v7 genopbyggede fundamentet, tilføjer 7.1 de dele, der gør blokke til mere: et databaselag, serverfunktioner, planlagte opgaver og en CLI. En blokmappe kan nu være en komplet applikation.

Her er alt det nye.

## Komponenter

Der har altid været en spænding mellem blokke, som redaktører bruger i indsætteren, og blokke, som udviklere bruger som byggeklodser til andre ting. Et kort, et badge, en statistik-widget, et formularfelt. De har brug for hele Blockstudio-pipelinen (attributter, skabeloner, aktiver, Tailwind), men bør ikke vises i indsætteren.

7.1 introducerer komponenter, der løser dette. Angiv `"component": true` i din block.json, så gennemgår blokken hele build-pipelinen, men registreres aldrig i WordPresss bloktyperegister. Den vises ikke i indsætteren og indgår ikke i editorens data, der sendes til JavaScript, men er fuldt tilgængelig til programmatisk rendering.

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

Render dem fra PHP:

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

Eller med den nye HTML-tagsyntaks:

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

## Bloktags

Blokke kan nu indlejres som HTML-tags med to syntakser, der kan bruges i flæng:

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

Begge giver samme resultat. Begge fungerer med Blockstudio-blokke og kerneblokkene i WordPress. Inde i blokskabeloner renderes de automatisk uden tilvalg. Det betyder, at du kan sammensætte hele layouts af andre blokke direkte i din skabelon:

```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 to syntakser kan frit indlejres i hinanden. Blockstudio-blokke renderes gennem hele pipelinen (skabeloner, Tailwind, aktiver). Kerneblokke renderes gennem WordPress med de samme renderere, som driver [Pages and Patterns](https://blockstudio.dev/da/docs/pages-and-patterns/).

Aktivér det i `blockstudio.json` for rendering på sideniveau (indlægsindhold, widgetområder):

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

Tilladelses- og afvisningslister styrer med jokertegnsmønstre, hvilke blokke der kan renderes via tags. Attributterne `data-*` og `html-*` overføres til det renderede blocks rodelement HTML. Brugerdefinerede renderere kan registreres via filteret `blockstudio/block_tags/renderers`.

Under motorhjelmen erstatter en ny, letvægts strengscanner DOMDocument fuldstændigt som tagparser. Den håndterer indlejrede tags med dybderegistrering, rekursive containerblokke og blandet syntaks i én gennemløbning. I benchmarks parser den 1,000 flade tags på 2.4ms og 100 indlejringsniveauer på 3.7ms, konsekvent hurtigere end både DOMDocument og WordPresss `WP_HTML_Tag_Processor`. Den samme parser håndterer også parsing af rå HTML-elementer til [Pages and Patterns](https://blockstudio.dev/da/docs/pages-and-patterns/) og erstatter den DOMDocument-baserede parser, der tidligere håndterede `<p>`, `<div>` og andre HTML-elementer.

## Nye felttyper

### Blok

En ny felttype `block`, der lader dig referere til en anden Blockstudio-blok som en attribut. Den refererede bloks felter foldes ind inline med `idStructure` og `overrides`, præcis som brugerdefinerede felter. Forskellen er, at værdien returnerer det renderede blokoutput, når du tilgår den i skabelonen.

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

Hvis `mytheme/card` har felterne `heading` og `content`, får værtsblokken `card_heading` og `card_content` i sidepanelet. I skabelonen sender `{{ a.card }}` det renderede kort ud. Fungerer med både almindelige blokke og komponenter.

### HTML-tag

Alle temaer har blokke, hvor overskriftsniveauet bør ændre sig afhængigt af konteksten. Et H1 på forsiden, et H2 på undersider. I stedet for hver gang at oprette dette som et select-felt med fastkodede valgmuligheder findes der nu en dedikeret felttype `html-tag` med indbyggede forudindstillinger.

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

Forudindstillinger: `heading` (h1-h6), `text` (overskrifter + p, span, div), `structural` (div, section, article, aside, main, header, footer, nav), `all`. Du kan også angive et brugerdefineret array. `exclude` fjerner bestemte tags fra enhver forudindstilling.

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

## Database

Dette er udgivelsens omdrejningspunkt. Tilføj en `db.php`-fil til en hvilken som helst blokmappe, så genererer Blockstudio fem REST CRUD-endpoints, validerer alle skrivninger mod skemaet, håndterer automatisk lagerbackend og leverer både en JavaScript-klient (`bs.db()`) og en PHP API (`Db::get()`). Ingen migrationsfiler, controllerklasser eller ruteregistrering.

```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']],
        ],
    ],
];
```

Alene dette skema opretter en fuldt fungerende API med endpoints til oprettelse, listevisning, hentning, opdatering og sletning, alle med inputvalidering.

### Lagring

Fem lagerbackends, hver egnet til forskellige brugsscenarier:

- **`table`**: Brugerdefineret MySQL-tabel, der håndteres via `dbDelta()`. Når felter føjes til skemaet, tilføjes kolonner ved næste sideindlæsning. Standardvalget til produktion.
- **`sqlite`**: Én enkelt SQLite-fil i blokkens `db/`-mappe. Ægte SQL-forespørgsler, WAL-tilstand til samtidige læsninger og fuldt portabel. Kopiér mappen, kopiér databasen.
- **`jsonc`**: Ét JSON-objekt pr. linje i en flad fil. Menneskeligt læsbar, versionsstyret og git-venlig.
- **`meta`**: JSON-array i WordPress-indlægsmeta, knyttet til et bestemt indlæg.
- **`post_type`**: Hver post bliver et WordPress-indlæg i en brugerdefineret indlægstype. Felter gemmes som individuelle indlægsmetaindgange og kan forespørges fuldt ud med `WP_Query`.

### Klienter

På JavaScript-siden giver `bs.db()` dig en komplet CRUD-klient:

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

Tre tilhørende hjælpeværktøjer følger med:

- **`bs.cache`**: En cache til forespørgsler i hukommelsen med `get`, `set`, `invalidate` og `clear`. Delt på tværs af alle forespørgsels- og muteringskald.
- **`bs.query(key, fn, options)`**: Pakker enhver asynkron funktion ind med caching, deduplikering af forespørgsler og konfigurerbar `staleTime`. Flere kald med samme nøgle, mens en forespørgsel er i gang, returnerer samme promise.
- **`bs.mutate(options)`**: Håndterer optimistiske mutationer med automatisk tilbagerulning. Giv den et reaktivt tilstandsobjekt, en handling (`create`, `update`, `delete`) og optimistiske data. UI opdateres øjeblikkeligt. Hvis serverkaldet mislykkes, rulles tilstanden tilbage til snapshot'et fra før mutationen.

Tilsammen dækker de hele læse- og skriveforløbet: `bs.query` til cachelagrede læsninger, `bs.mutate` til optimistiske skrivninger, `bs.cache` til manuel styring.

På PHP-siden leverer klassen `Db` de samme handlinger:

```php
use Blockstudio\Db;

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

### Validering

Valideringsfejl returneres som fejllister for hvert felt, inspireret af formatet `fieldErrors` fra Zod. Flere regler kan fejle for samme felt, og strukturen gør det nemt at knytte fejl til formularfelter i frontend:

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

Brugerdefinerede `validate`-callbacks køres på serveren for alt, som de indbyggede regler ikke dækker: blokering af domæner, validering på tværs af felter, eksterne opslag.

### Brugerspecifikke data

For data pr. bruger, som f.eks. opgaver, favoritter eller kladder, skal du sætte `userScoped` til `true`, så håndterer Blockstudio resten. Den tilføjer en `user_id`-kolonne, angiver den automatisk ved oprettelse og filtrerer alle forespørgsler efter den aktuelle bruger. Ejerskab kontrolleres ved opdateringer og sletninger. Intet manuelt `user_id`-felt, ingen `before_create`-hook, ingen filtrering i RPC. Én konfigurationslinje. Ved brug af `post_type`-lagring knyttes `userScoped` til `post_author` i stedet for en separat kolonne.

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

### Realtidsafstemning

Angiv `'realtime' => true` i dit skema, så forespørger klienten automatisk efter ændringer. Når noget ændres på serveren, opdateres Interactivity API-lageret, og UI rendres igen uden ændringer i JavaScript på din side. Konfigurer med `'realtime' => ['key' => 'todos', 'interval' => 5000]` for brugerdefinerede tilstandsnøgler og intervaller. Afstemningen bruger hash-sammenligning for at holde forespørgslerne lette og sættes på pause, når browserfanen er skjult.

### Sikkerhed, hooks og portabilitet

Offentlige endpoints beskyttes af en automatisk tilføjet CSRF-header `X-BS-Token`. Brug `'open'`, når du har brug for helt uautentificeret adgang, f.eks. til indgående webhooks.

Livscyklushooks udløses før og efter hver skrivehandling. Definér dem inline i `db.php` eller globalt via handlingerne WordPress.

Felter kan definere en `component`-nøgle til skemadrevet formularrendering via `bs_db_form()`.

Med SQLite- eller JSONC-lagring ligger hele applikationen i én mappe: koden, logikken, adgangskontrollen og dataene. Kopiér den for at udrulle.

## RPC

CRUD er ikke altid nok. Du har brug for brugerdefineret serverlogik: skift status på en opgave, send en notifikation, saml statistik. Det er det, `rpc.php` bruges til. Definér en PHP-funktion, kald den fra frontend med `bs.fn()`, så håndterer Blockstudio REST-endpointet, autentificering, CSRF-beskyttelse og JSON-serialisering. Mønstret er inspireret af [tRPC](https://trpc.io): procedurer defineres på serveren og kaldes fra klienten via navn.

```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`) finder automatisk bloknavnet ud fra attributten `data-block` på deres script-tag, så du ikke behøver angive det manuelt. Modulescripts angiver det som tredje argument.

Adgangskontrolmulighederne omfatter `public` (med CSRF), `'open'` (ingen beskyttelse), capability-strenge eller arrays. Kontrol af HTTP-metode pr. funktion, livscyklushooks og kald på tværs af blokke fra både JS og PHP understøttes også.

## Cron

Baggrundsopgaver defineres i en `cron.php`-fil. Angiv en tidsplan og et callback, så registrerer Blockstudio dem med WordPress Cron ved initialisering. Når pluginnet deaktiveres, fjernes alle planlagte opgaver korrekt.

```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 indbyggede WordPress-tidsplaner understøttes samt brugerdefinerede intervaller via filteret `cron_schedules`.

## CLI

En ny `wp bs`-kommando dækker hele funktionssættet i Blockstudio: blokke, database, RPC, cron, indstillinger, kompilering af Tailwind, kompilering af SCSS, brugerdefinerede felter og håndtering af aktiver.

```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 kommandoer understøtter `--format=json` til scripting.

## Forbedringer af gentagelsesfelter

### textMinimized for objektfelter

Sammenfoldede gentagelsesrækker håndterer nu værdier fra objektfelter korrekt. Tidligere viste `textMinimized` `[object Object]`, når det pegede på et linkfelt. Nu aflæser Blockstudio automatisk den rigtige underegenskab ud fra felttypen: `title` for links, `value` for farver og gradienter, `icon` for ikoner. Du kan også angive en eksplicit `key`-egenskab for at læse en vilkårlig underegenskab.

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

### RichText og MediaPlaceholder

Begge skabelonkomponenter fungerer nu i gentagelsesfelter med klammeparentesnotation, så den rigtige række målrettes. Overskrifter, afsnit og medie-uploadområder kan redigeres inline i hver række i et gentagelsesfelt.

```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 %}
```

## Betingelser for brugerdefinerede felter med idStructure

Når du bruger et brugerdefineret felt med `idStructure`, omskrives ID'erne i betingelserne i feltdefinitionen nu automatisk, så de passer til de udvidede navne. Hvis din feltgruppe til skriftstørrelse har en betingelse på `enable` og du udvider den med `idStructure: "title_font_{id}"`, henviser betingelsen nu korrekt til `title_font_enable` i stedet for det oprindelige `enable`.

Betingelser på referenceniveau understøttes også. Tilføj `conditions` til referencen til det brugerdefinerede felt for at anvende dem på alle udvidede felter på én gang.

## Dynamiske populate-argumenter

Populate-argumenter kan nu referere til andre blokattributter med syntaksen `{attributes.*}`. Når den refererede attribut ændres, henter select-feltet automatisk sine valgmuligheder igen. Kæd select-felter sammen: ét til valg af indlægstype og et andet, der indlæser indlæg af den type.

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

Skift `post_type` til "page", så indlæser det andet select-felt sider. Skift det til "post", så indlæser det indlæg. Fungerer med alle populate-typer og attributter.

## Composer

Blockstudio fungerer nu, når det indlæses fra et vilkårligt sted under `wp-content/`, ikke kun fra pluginmappen. Aktivernes URL'er opløses via konstanten `BLOCKSTUDIO_URL` i stedet for `plugins_url()`, så installationer, der er indlejret i temaer, virker uden yderligere opsætning:

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

Afhængighederne under kørsel for `composer.json` er blevet ryddet op. Afgrænsede pakker (TailwindPHP, ScssPhp, Minify), der allerede er bundtet i `lib/`, er ikke længere angivet som runtime-afhængigheder. Kun `php >= 8.2` og `plugin-update-checker` er tilbage.

Alle tre installationsmetoder (plugin-zip, plugin via Composer, temabundtet via Composer) starter med samme resultat: fuld aktivering af WordPress, blokregistrering og frontend-rendering.

Se dokumentationen for [Composer](https://blockstudio.dev/da/docs/dev/composer/) for opsætningsvejledning.

## Ydelsesprofilering

Tilføj `?blockstudio-perf` til en hvilken som helst side URL, så vises et fejlfindingspanel nederst med rendertider pr. blok, faseopdeling og cache-træffrekvenser. Tidsdata sendes også i Server-Timing-headere, som kan ses under Netværk i browserens DevTools.

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

Aktivér den permanent via indstillingerne for at profilere hver sideindlæsning. Den er kun synlig for indloggede brugere med capability `edit_posts`.

Selvlukkende bloktags caches nu også i hukommelsen. Når den samme blok med identiske attributter vises flere gange på en side, springer efterfølgende renderinger hele skabelonpipelinen over.

## Fejlrettelser

- **Advarsler om forældelse i PHP 8.4**: Rettede forældelsesadvarsler for `strpos()` og `str_replace()`, der skyldtes, at `null` blev sendt til `add_submenu_page()`.

## Mere

- **SCSS-kodefelter**: Kodefelter understøtter `language: "scss"`. Værdier kompileres via ScssPhp både i editoren og på frontend.
- **Standard-WordPress-blokke**: Blockstudio-mapper kan indeholde `@wordpress/create-block`-output sammen med Blockstudio-blokke. De registreres automatisk uden separat pluginkode.

---

Hvis du vil se full-stack-mønstret i praksis, gennemgår guiden [Full-Stack Blocks](https://blockstudio.dev/da/guides/full-stack-blocks/), hvordan man fra bunden bygger en opgaveapp med data pr. bruger og en offentlig tilmelding til nyhedsbreve.
