
Blockstudio 7.1 är den första funktionsreleasen sedan omskrivningen av v7. Där v7 lade om grunden tillför 7.1 delarna som gör block till något mer: ett databaslager, serverfunktioner, schemalagda uppgifter och en CLI. En blockmapp kan nu vara en komplett applikation.

Här är allt nytt.

## Komponenter

Det har alltid funnits en spänning mellan block som redaktörer använder i infogaren och block som utvecklare använder som byggstenar för annat. Ett kort, en bricka, en statistikwidget, ett formulärfält. De behöver hela Blockstudio-pipen (attribut, mallar, tillgångar, Tailwind), men har inget i infogaren att göra.

7.1 introducerar komponenter för att lösa detta. Ange `"component": true` i din block.json så går blocket genom hela byggpipen, men registreras aldrig i WordPresss blocktypsregister. Det visas inte i infogaren och visas inte i redigeringsdata som skickas till JavaScript, men är fullt tillgängligt för programmatisk rendering.

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

Rendera dem från PHP:

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

Eller använd den nya taggsyntaxen HTML:

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

## Blocktaggar

Block kan nu bäddas in som HTML-taggar med två utbytbara syntaxer:

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

Båda ger samma resultat. Båda fungerar med Blockstudio-block och kärnans WordPress-block. I blockmallar renderas de automatiskt utan att något behöver aktiveras. Det innebär att du kan sätta samman hela layouter av andra block direkt i mallen:

```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 två syntaxerna kan nästlas fritt i varandra. Blockstudio-block renderas genom hela pipen (mallar, Tailwind, tillgångar). Kärnblock renderas via WordPress med samma renderare som används för [Sidor och mönster](https://blockstudio.dev/sv/docs/pages-and-patterns/).

Aktivera det i `blockstudio.json` för rendering på sidnivå (inläggsinnehåll, widgetområden):

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

Tillåt- och neka-listor styr vilka block som kan renderas via taggar med jokerteckenmönster. Attributen `data-*` och `html-*` skickas vidare till det renderade blockets rot-HTML-element. Anpassade renderare kan registreras via filtret `blockstudio/block_tags/renderers`.

Under huven ersätter en ny, lättviktig strängskanner DOMDocument helt som taggparser. Den hanterar nästlade taggar med djupspårning, rekursiva behållarblock och blandad syntax i ett enda svep. I riktmärken tolkar den 1,000 platta taggar på 2.4ms och 100 nivåer av nästling på 3.7ms, konsekvent snabbare än både DOMDocument och WordPresss `WP_HTML_Tag_Processor`. Samma parser hanterar också tolkning av råa HTML-element för [Sidor och mönster](https://blockstudio.dev/sv/docs/pages-and-patterns/), och ersätter den DOMDocument-baserade parser som tidigare hanterade `<p>`, `<div>` och andra HTML-element.

## Nya fälttyper

### Block

En ny fälttyp `block` som låter dig hänvisa till ett annat Blockstudio-block som attribut. Det refererade blockets fält expanderas direkt med `idStructure` och `overrides`, precis som anpassade fält. Skillnaden är att när du hämtar värdet i mallen får du det renderade blockresultatet.

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

Om `mytheme/card` har fälten `heading` och `content` får värdblocket `card_heading` och `card_content` i sidofältet. I mallen visar `{{ a.card }}` det renderade kortet. Fungerar med både vanliga block och komponenter.

### Taggen HTML

I varje tema finns det block där rubriknivån bör ändras beroende på sammanhanget. En H1 på startsidan, en H2 på undersidor. I stället för att varje gång skapa detta som ett urvalsfält med hårdkodade alternativ finns nu en särskild fälttyp `html-tag` med inbyggda förinställningar.

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

Förinställningar: `heading` (h1-h6), `text` (rubriker + p, span, div), `structural` (div, section, article, aside, main, header, footer, nav), `all`. Du kan också skicka in en anpassad array. `exclude` tar bort specifika taggar från valfri förinställning.

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

## Databas

Det här är releasens huvudnyhet. Lägg till en `db.php`-fil i valfri blockkatalog så genererar Blockstudio fem REST-CRUD-ändpunkter, validerar varje skrivning mot schemat, hanterar lagringsbackend automatiskt och tillhandahåller både en JavaScript-klient (`bs.db()`) och en PHP API (`Db::get()`). Inga migreringsfiler, inga controllerklasser, ingen ruttregistrering.

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

Bara det schemat skapar ett fullt fungerande API med ändpunkter för att skapa, lista, hämta, uppdatera och ta bort, alla med indatavalidering.

### Lagring

Fem lagringsbackendar, var och en lämpad för olika användningsområden:

- **`table`**: Anpassad MySQL-tabell som hanteras via `dbDelta()`. När du lägger till fält i schemat tillkommer kolumner vid nästa sidladdning. Standardvalet i produktion.
- **`sqlite`**: En enda SQLite-fil i blockets mapp `db/`. Riktiga SQL-frågor, WAL-läge för samtidiga läsningar och helt portabelt. Kopiera mappen, så kopieras databasen.
- **`jsonc`**: Ett JSON-objekt per rad i en platt fil. Läsbart för människor, versionshanteringsvänligt, git-vänligt.
- **`meta`**: Arrayen JSON i WordPress-postmeta, knuten till ett specifikt inlägg.
- **`post_type`**: Varje post blir ett WordPress-inlägg i en anpassad inläggstyp. Fälten lagras som separata postmeta-poster och kan sökas med `WP_Query`.

### Klienter

På JavaScript-sidan ger `bs.db()` dig en komplett 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 kompletterande verktyg ingår också:

- **`bs.cache`**: En frågecache i minnet med `get`, `set`, `invalidate` och `clear`. Delas mellan alla fråge- och ändringsanrop.
- **`bs.query(key, fn, options)`**: Förser valfri asynkron funktion med cachelagring, deduplicering av förfrågningar och konfigurerbar `staleTime`. Flera anrop med samma nyckel medan en förfrågan pågår får samma promise tillbaka.
- **`bs.mutate(options)`**: Hanterar optimistiska ändringar med automatisk återställning. Skicka in ett reaktivt tillståndsobjekt, en åtgärd (`create`, `update`, `delete`) och optimistiska data. UI uppdateras direkt. Om serveranropet misslyckas återställs tillståndet till ögonblicksbilden före ändringen.

Tillsammans täcker dessa hela läs- och skrivcykeln: `bs.query` för cachelagrade läsningar, `bs.mutate` för optimistiska skrivningar, `bs.cache` för manuell kontroll.

På PHP-sidan tillhandahåller klassen `Db` samma åtgärder:

```php
use Blockstudio\Db;

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

### Validering

Valideringsfel returneras som felarrayer per fält, inspirerade av formatet `fieldErrors` i Zod. Flera regler kan fallera för samma fält, och strukturen gör det enkelt att koppla fel till formulärfält på frontend:

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

Anpassade återanrop i `validate` körs på serversidan för sådant som de inbyggda reglerna inte täcker: blockering av domäner, validering mellan fält och externa uppslagningar.

### Användaravgränsade data

För användarspecifika data som att-göra-listor, favoriter eller utkast anger du `userScoped` som `true`, så sköter Blockstudio resten. Den lägger till en `user_id`-kolumn, fyller i den automatiskt vid skapande och filtrerar varje fråga för den aktuella användaren. Uppdateringar och borttagningar kontrollerar ägarskapet. Inget manuellt `user_id`-fält, ingen `before_create`-hook och ingen filtrering i RPC. En konfigurationsrad. När du använder lagringen `post_type` mappas `userScoped` till `post_author` i stället för en separat kolumn.

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

### Realtime-avläsning

Ange `'realtime' => true` i schemat så söker klienten automatiskt efter ändringar. När något ändras på servern uppdateras lagret Interactivity API och UI renderas om utan några JavaScript-ändringar från din sida. Konfigurera med `'realtime' => ['key' => 'todos', 'interval' => 5000]` för anpassade tillståndsnycklar och intervall. Avläsningen använder hashjämförelse för att hålla förfrågningarna lätta och pausas när webbläsarfliken är dold.

### Säkerhet, hooks och portabilitet

Publika ändpunkter skyddas av en automatiskt tillagd CSRF-header `X-BS-Token`. Använd `'open'` när du behöver åtkomst helt utan autentisering, till exempel för inkommande webhooks.

Livscykel-hooks körs före och efter varje skrivåtgärd. Definiera dem direkt i `db.php` eller globalt via åtgärderna WordPress.

Fält kan definiera en nyckel `component` för schemadriven formulärrendering via `bs_db_form()`.

Med lagringen SQLite eller JSONC ryms hela applikationen i en mapp: koden, logiken, åtkomstkontrollen och data. Kopiera mappen för att driftsätta.

## RPC

Ibland räcker inte CRUD. Du kan behöva anpassad serverlogik: växla status för en att-göra-uppgift, skicka en avisering eller sammanställa statistik. Det är vad `rpc.php` är till för. Definiera en funktion PHP, anropa den från frontend med `bs.fn()`, så hanterar Blockstudio REST-ändpunkten, autentisering, CSRF-skydd och serialisering av JSON. Mönstret är inspirerat av [tRPC](https://trpc.io): procedurer definieras på serversidan och anropas från klienten med namn.

```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-skript (`script-inline.js`) identifierar automatiskt blocknamnet från attributet `data-block` på skripttaggen, så du behöver inte ange det manuellt. Modulskript skickar med det som tredje argument.

Åtkomstkontrollalternativen omfattar `public` (med CSRF), `'open'` (utan skydd), behörighetssträngar eller arrayer. Styrning av HTTP-metod per funktion, livscykel-hooks och anrop mellan block från både JS och PHP stöds också.

## Cron

Bakgrundsuppgifter definieras i en `cron.php`-fil. Ange ett schema och ett återanrop, så registrerar Blockstudio dem med WordPress Cron vid initiering. När tillägget inaktiveras avschemaläggs allt 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
        },
    ],
];
```

Alla inbyggda WordPress-scheman stöds, liksom anpassade intervall via filtret `cron_schedules`.

## CLI

Ett nytt `wp bs`-kommando täcker hela funktionsuppsättningen i Blockstudio: block, databas, RPC, cron, inställningar, kompilering av Tailwind, kompilering av SCSS, anpassade fält och hantering av tillgångar.

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

Alla kommandon stöder `--format=json` för skriptning.

## Förbättringar av upprepningsfält

### textMinimized för objektfält

Komprimerade rader i upprepningsfält hanterar nu värden från objektfält korrekt. Tidigare visades `[object Object]` när `textMinimized` pekade på ett länkfält. Nu läser Blockstudio automatiskt rätt underordnad egenskap utifrån fälttypen: `title` för länkar, `value` för färger och gradienter, `icon` för ikoner. Du kan också ange en uttrycklig egenskap `key` för att läsa vilken underordnad egenskap du vill.

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

### RichText och MediaPlaceholder

Båda mallkomponenterna fungerar nu i upprepningsfält med hakparentesnotation för att rikta in sig på rätt rad. Rubriker, stycken och mediauppladdningszoner i varje rad kan redigeras direkt.

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

## Villkor för anpassade fält med idStructure

När ett anpassat fält används med `idStructure` skrivs ID:n i villkor i fältdefinitionen nu automatiskt om så att de matchar de expanderade namnen. Om fältgruppen för teckenstorlek har ett villkor på `enable` och du expanderar den med `idStructure: "title_font_{id}"` refererar villkoret nu korrekt till `title_font_enable` i stället för det ursprungliga `enable`.

Villkor på referensnivå stöds också. Lägg till `conditions` i referensen till det anpassade fältet för att tillämpa dem på alla expanderade fält samtidigt.

## Dynamiska parametrar för populate

Populate-parametrar kan nu referera till andra blockattribut med syntaxen `{attributes.*}`. När det refererade attributet ändras hämtar urvalsfältet automatiskt sina alternativ på nytt. Kedja ihop urvalsfält: ett för att välja inläggstyp och ett annat som läser in inlägg av den typen.

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

Ändra `post_type` till "page" så läser det andra urvalsfältet in sidor. Ändra det till "post" så läser det inlägg. Fungerar med alla populate-typer och attribut.

## Composer

Blockstudio fungerar nu oavsett var under `wp-content/` det laddas, inte bara från tilläggskatalogen. URL:er till tillgångar löses via en konstant `BLOCKSTUDIO_URL` i stället för `plugins_url()`, så installationer med temainnehåll fungerar direkt:

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

Körtidsberoendena för `composer.json` har rensats upp. Avgränsade paket (TailwindPHP, ScssPhp, Minify) som redan ingår i `lib/` listas inte längre som körtidsberoenden. Bara `php >= 8.2` och `plugin-update-checker` återstår.

Alla tre installationsmetoder (tilläggs-zip, tillägg via Composer, temainbäddat via Composer) ger samma resultat vid start: full aktivering av WordPress, blockregistrering och rendering på frontend.

Se dokumentationen [Composer för installationsanvisningar](https://blockstudio.dev/sv/docs/dev/composer/).

## Prestandaprofilerare

Lägg till `?blockstudio-perf` på valfri sida URL så visas en felsökningspanel längst ned med renderingstider per block, fasuppdelningar och cacheträffsfrekvenser. Tidsdata skickas också som Server-Timing-headers och visas på fliken Network i webbläsarens DevTools.

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

Aktivera den permanent via inställningarna för att profilera varje sidladdning. Den är bara synlig för inloggade användare med behörigheten `edit_posts`.

Självstängande blocktaggar cachelagras nu också i minnet. När samma block med identiska attribut förekommer flera gånger på en sida hoppar efterföljande renderingar över hela mallpipen.

## Felkorrigeringar

- **PHP 8.4, utfasningsvarningar**: Åtgärdade utfasningsvarningar för `strpos()` och `str_replace()` som orsakades av att `null` skickades till `add_submenu_page()`.

## Mer

- **SCSS-kodfält**: Kodfält stöder `language: "scss"`. Värden kompileras genom ScssPhp både i redigeraren och på frontend.
- **Standardblock för WordPress**: Kataloger för Blockstudio kan innehålla utdata från `@wordpress/create-block` tillsammans med block för Blockstudio. De registreras automatiskt utan separat tilläggskod.

---

Om du vill se fullstackmönstret i praktiken går guiden [Fullstackblock](https://blockstudio.dev/sv/guides/full-stack-blocks/) igenom hur du bygger en att-göra-app för enskilda användare och ett offentligt nyhetsbrevsformulär från grunden.
