
Blockstudio 7 er her. Det er den største udgivelse i projektets
historie: en komplet omskrivning af hele kodebasen fra bunden. Hver klasse,
hvert hook, hver kodelinje er bygget om fra grunden med fokus på moderne
PHP, WordPress-kodestandarder og langsigtet vedligeholdelse.

Men det er ikke bare en refaktorering. Blockstudio 7 introducerer store nye funktioner
som filbaserede sider og mønstre, et lagringssystem til indlæggets meta-data,
integration med SEO og en helt ny parser fra HTML til blokke, som driver det hele. Derudover er Blockstudio nu helt gratis og open source.

Lad os se nærmere på alt det nye.

## Gratis og open source

Jeg har arbejdet på Blockstudio siden 2020 og udgivet snesevis af versioner gennem
årene. De, der brugte det, var glade for det, men det var altid en udfordring at
finde et produkt-marked-match for et kommercielt blokframework til WordPress.

Det, der ændrede regnestykket, er LLM'er. AI-kodeassistenter er nu gode nok til at
skrive blokkode, men de har brug for rene, filbaserede strukturer at arbejde med.
WordPress-blokmarkering er rodet: serialiserede HTML-kommentarer med indlejrede
JSON-attributter blandet med DOM-struktur. Det er svært for mennesker og endnu sværere for
LLM'er at få rigtigt.

Blockstudios filbaserede tilgang var altid designet til at holde tingene enkle:
en `block.json` og en PHP-skabelon i en mappe. Ingen databaseposter, ingen React,
intet buildtrin. Med v7 går den filosofi endnu videre. Parseren fra HTML til blokke
lader dig skrive ren HTML, som automatisk konverteres til gyldig blokmarkering.
Alt forbliver i filsystemet. De eneste skrivninger til databasen er
sidesynkroniseringer, der udtrykkeligt anmodes om via PHP API eller CLI,
og de styres af skabeloner i filer.

Det er et naturligt næste skridt at gøre Blockstudio open source. Jo mere LLM'er trænes på
Blockstudio-kode, desto bedre bliver de til at generere den. En åben kodebase,
åben dokumentation og en færdigbygget
[AI-kontekstfil](https://blockstudio.dev/da/docs/dev/ai/), som ethvert værktøj kan bruge: sådan skaber man de bedste
rammer for AI-assisteret udvikling med WordPress.

Hele plugin'et findes på
[GitHub](https://github.com/inline0/blockstudio), hvor alle kan bruge, forke og
bidrage til det. Ingen licensnøgler, betalingsmure eller funktionsbegrænsninger.

## Nye funktioner

### Filbaserede sider

Dette er en af de største tilføjelser i 7.0. Du kan nu definere hele
WordPress-sider som skabeloner i filer, der synkroniseres til databasen som indhold i
native blokformat, når du starter sidesynkroniseringen med API eller CLI.

Opret en mappe med en `page.json` og en skabelonfil:

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

Kør `wp bs pages sync` for at lade Blockstudio parse HTML til WordPress-blokke
og oprette eller opdatere siden i databasen.

#### Fletning af blokke efter nøgle

Når skabeloner synkroniseres, ville brugerredigeringer normalt blive overskrevet. Attributten `key` løser dette ved at bevare brugerindhold mellem synkroniseringer:

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

Blokke med matchende nøgler bevarer det brugerredigerede indhold, når skabelonen
opdateres. Blokke uden nøgler erstattes helt.

#### Blokbindinger

Som alternativ til nøgler kan du bruge WordPress-kernefunktionens
[Block Bindings API](https://developer.wordpress.org/block-editor/reference-guides/block-api/block-bindings/) til at forbinde blokke direkte med indlæggets meta-data. Dette er ikke en funktion i Blockstudio, men en indbygget WordPress API. Blockstudio sender blot attributten `metadata` videre til den genererede blokmarkering. Indholdet ligger i meta-data i stedet for blokmarkeringen, så synkronisering af skabeloner aldrig ødelægger brugerredigeringer. Dataene kan også forespørges via `WP_Query` og tilgås gennem REST API.

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

Begge metoder kan bruges i den samme skabelon.

#### Redigeringskontroller

Sider understøtter `blockEditingMode` og `templateLock` til at styre, hvad brugerne kan
ændre:

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

Dette låser sidens struktur, mens brugerne stadig kan redigere tekst og
medier. Individuelle elementer kan tilsidesætte indstillingen på sideniveau med
en attribut `blockEditingMode` i skabelonen.

#### Fastgørelse til indlægs-id'er

Brug `postId` til at knytte en sideskabelon til et eksisterende WordPress-indlæg, så
du undgår dublerede sider og sikrer, at skabelonen altid opdaterer det rigtige indlæg:

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

Se [dokumentationen om Pages](https://blockstudio.dev/da/docs/pages-and-patterns/pages/) for alle detaljer.

### Filbaserede mønstre

Ligesom med sider kan du nu definere blokmønstre som skabeloner i filer. Skriv
dit mønster i HTML, så parser Blockstudio det til blokmarkering og
registrerer det som et indbygget WordPress-blokmønster. De vises i blokindsætteren
og kan placeres hvor som helst af brugerne.

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

I modsætning til sider opretter mønstre ikke databaseposter. De registreres i
hukommelsen ved hver sideindlæsning. Se
[dokumentationen om Patterns](https://blockstudio.dev/da/docs/pages-and-patterns/patterns/).

### Parser fra HTML til blokke

Både sider og mønstre drives af en ny parser til HTML, der konverterer standard-
HTML-skabeloner til blokmarkering i WordPress. Den håndterer automatisk containerblokke
(som grupper og kolonner) og bladblokke (som afsnit og overskrifter). Parseren bruger en
rendererarkitektur baseret på traits, så det er nemt at udvide den med understøttelse af flere bloktyper via
filteret `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 );
```

Når blokken er registreret, kan du bruge den i enhver side- eller mønsterskabelon:

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

### Lagring

Felter kan nu gemme deres værdier i indlæggets meta-data eller webstedets indstillinger ud over
blokattributter. Det er en stor nyhed:

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

Når værdierne ligger i indlæggets meta-data, kan du:

- Forespørge på indlæg efter feltværdier med `WP_Query` og `meta_query`
- Tilgå feltdata gennem REST API til headless-opsætninger
- Dele data med andre plugins som SEO-værktøjer og cachelag

Du kan også gemme værdier i indstillingstabellen til globale indstillinger for hele webstedet:

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

Se [dokumentationen om Storage](https://blockstudio.dev/da/docs/blocks/storage/) for hele API.

### Brugerdefinerede felter

Genanvendelige feltdefinitioner kan nu deles mellem flere blokke. Definér et
sæt felter én gang, og referér så til dem fra enhver blok. Det fjerner
gentagelser, når flere blokke deler den samme feltstruktur.

Opret en `field.json` i din blockstudio-mappe:

```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" }
  ]
}
```

Referér derefter til den fra enhver blok ved hjælp af præfikset `custom/`:

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

Egenskaben `idStructure` sætter præfiks foran hvert felt-id, så `heading` bliver til
`hero_heading`. Du kan også tilsidesætte individuelle feltegenskaber for hver forekomst
med nøglen `overrides`.

Se [dokumentationen om Custom Fields](https://blockstudio.dev/da/docs/blocks/attributes/custom-fields/).

### Tailwind CSS v4

Tailwind-understøttelsen er blevet fuldstændig genopbygget til v4. I stedet for at kompilere på klientsiden via CDN og gemme på disk, når indlægget gemmes (v6-tilgangen), kompilerer Blockstudio 7 Tailwind på serversiden ved hver frontend-anmodning via [TailwindPHP](https://github.com/dnnsjsk/tailwindphp). Ingen Node.js, ingen CLI, intet buildtrin nødvendigt.

Kompileringen bruger cache baseret på kandidater: Blockstudio udtrækker alle CSS-klassenavne fra den endelige HTML, sorterer dem og hasher dem sammen med din CSS-konfiguration og søger efter en cachet fil. De samme klasser giver samme cachehit, selv når den omgivende HTML ændres (nonces, tidsstempler, dynamisk indhold).

Konfigurationen bruger syntaksen CSS-først i Tailwind v4. Definér brugerdefinerede temaer og utility-klasser direkte i din `blockstudio.json` eller via filteret `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;
      }
    }
  ';
});
```

I blokeditoren giver et medfølgende script til Tailwind CDN en liveforhåndsvisning, mens du skriver. Felttypen `classes` tilbyder autofuldførelse for alle Tailwind-utilities. Frontend bruger altid den serverkompilerede CSS, indsat som et inline style-tag før `</head>`.

Se [dokumentationen om Tailwind](https://blockstudio.dev/da/docs/tailwind/) for hele opsætningen.

### Interaktivitet API

Blockstudio understøtter nu
[WordPress Interactivity API](https://developer.wordpress.org/block-editor/reference-guides/interactivity-api/).
Aktivér det i din block.json:

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

Føj `data-wp-*`-direktiver til din skabelon:

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

Opret derefter en `script.js` med din storelogik:

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

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

Blockstudio håndterer importmap, modulindlæsning og direktivbehandling både på
frontend og i blokeditoren. Blokke, der kun bruger deklarative direktiver med
`data-wp-context` (som `data-wp-bind--hidden` eller
`data-wp-text`), fungerer helt uden JavaScript. Tilstand på serversiden via
`wp_interactivity_state()` understøttes også på frontend.

Se [dokumentationen om Interactivity](https://blockstudio.dev/da/docs/blocks/interactivity/) for hele opsætningen.

### Indholdsanalyse med SEO

Blockstudio-blokke er dynamiske, så deres feltindhold er som standard usynligt for SEO-plugins. Blockstudio 7 løser dette med automatiske integrationer for Yoast SEO, Rank Math og SEOPress. Tekstværdier fra felterne `text`, `textarea`, `richtext`, `wysiwyg` og `link` (inklusive indlejrede rækker i gentagelsesfelter) udtrækkes og indgår i hvert plugins indholdsanalyse. SEO-plugins kan nu analysere dit blokindhold korrekt for søgeordstæthed, læsbarhed og andre målinger. Ingen konfiguration nødvendig.

### Standardrækker i gentagelsesfelter

Gentagelsesfelter understøtter nu egenskaben `default` med en række forudfyldte
rækker. Når en blok indsættes, udfyldes gentagelsesfeltet med de angivne
rækker og deres værdier, både i editoren og på 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" }
  ]
}
```

Egenskaben `min` fungerer også med standardværdier på feltniveau: Hvis et gentagelsesfelt har `min: 3`, og dets indre felter har værdierne `default`, udfyldes de automatisk genererede rækker med disse standardværdier i stedet for at være tomme.

## Forbedringer og rettelser

- **Gentagelsesfelt `min` med standardværdier for felter**: automatisk genererede minimumsrækker bruger nu standardværdier på feltniveau både på frontend og i editoren
- **Editorstile til Tailwind**: kompileret Tailwind CSS indsættes nu i blokeditorens iframe sammen med CDN, så brugerdefinerede regler for `@apply` og temakonfiguration fungerer i editoren
- **[AI-kontekstfil](https://blockstudio.dev/da/docs/dev/ai/)**: `blockstudio-llm.txt` er blevet genopbygget som en statisk fil sammensat af hele v7-dokumentationen og deduplikerede JSON-skemaer (~48k tokens), som erstatter den dynamiske generering fra v6
- **Kodefelt i separat vindue**: kodefeltet kan nu åbnes i et separat vindue med uafhængig fortryd/gentag og syntaksfremhævning for JavaScript
- **Kompilering på serversiden for Tailwind v4**: se afsnittet [Tailwind](#tailwind-css-v4) ovenfor
- **Version 3 af API**: blokke gengives nu korrekt i editoren med iframe, inklusive Site Editor og responsive forhåndsvisninger
- **Punktnotation for assets**: renere navngivningskonvention for asset-suffikser (`*.inline.css`, `*.editor.js`, `*.scoped.css`)
- Rettede advarsel om `bs_render_block()` fra `WP_Block_Supports` ved brug af `useBlockProps`
- Rettede betingede felter, der ikke respekterede standardværdier ved første indlæsning
- Rettede dollartegn, der blev fjernet fra `<RichText />`-indhold på frontend
- Rettede funktionen `populate`, så den virker med taksonomier registreret af andre plugins
- Rettede null-fejl for `optionsPopulate` i WPML-kontekster

## Bag kulisserne

### Fuldstændig omskrivning

Dette er ikke en refaktorering eller oprydning. Hver klasse er skrevet om fra
bunden. Resultatet er en renere og mere modulær kodebase, der er nemmere at
vedligeholde og udvide.

### Moderne PHP

Blockstudio 7 kræver PHP 8.2+ og bruger moderne typeangivelser overalt.

## Ændringer, der bryder kompatibiliteten

Som større versionsopdatering indeholder 7.0 flere ændringer, der bryder kompatibiliteten. De fleste har bagudkompatible alternativer, men du bør gennemgå dem før opgradering. Se den komplette [migreringsdokumentation for v7](https://blockstudio.dev/da/docs/dev/migration/v7/).

### Hooknavne bruger nu snake_case

Alle PHP-hooks er omdøbt fra camelCase til snake_case i overensstemmelse med WordPress-kernens konventioner:

```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 gamle camelCase-navne virker stadig, men vi anbefaler at opdatere dem.

### Feltkontakten er som standard slået fra

Egenskaben `switch` har nu som standard værdien `false` i stedet for `true`. I v6 havde hvert felt en usynlig kontakt i venstre kant, som var slået til som standard. I v7 er kontakten valgfri og bruger et synligt øjeikon i feltetiketten. Hvis du var afhængig af kontaktens standardadfærd, skal du tilføje `"switch": true` til dine feltdefinitioner.

### Assetfilnavne bruger punktnotation

Asset-suffikser bruger nu punktummer i stedet for bindestreger (`style.inline.css` i stedet for
`style-inline.css`). Den gamle notation med bindestreger virker stadig, men punktnotation er den
anbefalede konvention fremover.

### Importpræfiks for npm

ES-modulimporter bruger nu `npm:` i stedet for `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";
```

Præfikset `blockstudio/` understøttes stadig af hensyn til bagudkompatibilitet.

### Fjernede funktioner

**Administrationsområde og kodeeditor.** Administrationssiden for WordPress-indstillinger og den indbyggede blok-kodeeditor er begge fjernet. Al konfiguration foregår nu via filtrene `blockstudio.json` og PHP, så din opsætning ligger i versionsstyring sammen med dine blokke.

Kodeeditoren var nyttig i tidligere versioner til forhåndsvisning af blokke, men
nåede aldrig fuld paritet med et rigtigt udviklingsmiljø. Flere pluginfunktioner
blev holdt tilbage gennem årene, fordi de ikke kunne understøttes i den
selvstændige editor. Den ville heller aldrig kunne erstatte et komplet IDE. Når
den fjernes, kan plugin'et fokusere fuldt ud på filbaseret udvikling uden
kompromiser.

**Licensnøgle.** Ikke længere nødvendig. Blockstudio er gratis og open source.

**Blokbibliotek.** Det indbyggede bibliotek "Blockstudio Elements" (Gallery, Slider,
Image Comparison, Code, Icon) er fjernet. Det var færdigbyggede eksempelblokke,
der fulgte med plugin'et. Hvis du brugte dem, skal du kopiere blokmapperne fra
v6 til dit temas blockstudio-mappe.

## Kom godt i gang

Installér Blockstudio 7, og opret din første blok på få minutter. Se
[vejledningen Kom godt i gang](https://blockstudio.dev/da/docs/general/getting-started/) for en trinvis gennemgang,
eller [migreringsvejledningen for v7](https://blockstudio.dev/da/docs/dev/migration/v7/), hvis du opgraderer fra v6.

Hele kildekoden findes på
[GitHub](https://github.com/inline0/blockstudio). Fejlrapporter, pull requests og feedback
modtages gerne.
