
Blockstudio 7.1 je první vydání s novými funkcemi od přepsání v7. Zatímco v7 přestavělo základy, verze 7.1 přidává součásti, které z bloků dělají něco víc: databázovou vrstvu, serverové funkce, plánované úlohy a CLI. Ze složky bloku se nyní může stát kompletní aplikace.

Tady je přehled všech novinek.

## Komponenty

Mezi bloky, které editoři používají v nabídce pro vkládání, a bloky, které vývojáři používají jako stavební prvky pro další věci, vždy panovalo určité napětí. Karta, štítek, statistický widget, vstupní pole formuláře. Potřebují celý proces sestavení Blockstudio (atributy, šablony, prostředky, Tailwind), ale v nabídce pro vkládání nemají co dělat.

Verze 7.1 tento problém řeší zavedením komponent. Nastavte `"component": true` v souboru block.json a blok projde celým procesem sestavení, ale nezaregistruje se v registru typů bloků WordPress. Nezobrazí se v nabídce pro vkládání ani v datech editoru odesílaných do JavaScript, ale je plně dostupný pro programové vykreslování.

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

Vykreslete je z PHP:

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

Nebo použijte novou syntaxi značek HTML:

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

## Značky bloků

Bloky lze nyní vkládat jako značky HTML pomocí dvou zaměnitelných syntaxí:

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

Obě vytvářejí stejný výstup. Fungují s bloky Blockstudio i základními bloky WordPress. Uvnitř šablon bloků se vykreslují automaticky, bez nutnosti cokoli povolovat. Celá rozvržení tak můžete skládat z dalších bloků přímo v šabloně:

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

Obě syntaxe lze libovolně vnořovat. Bloky Blockstudio procházejí celým procesem vykreslování (šablony, Tailwind, prostředky). Základní bloky se vykreslují přes WordPress pomocí stejných vykreslovačů, které používají [Pages a Patterns](https://blockstudio.dev/cs/docs/pages-and-patterns/).

Chcete-li vykreslování na úrovni stránky (obsah příspěvku, oblasti widgetů), povolte ho v `blockstudio.json`:

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

Seznamy povolených a zakázaných bloků určují pomocí zástupných vzorů, které bloky lze vykreslit pomocí značek. Atributy `data-*` a `html-*` se předávají kořenovému prvku HTML vykresleného bloku. Vlastní vykreslovače lze zaregistrovat pomocí filtru `blockstudio/block_tags/renderers`.

Značky nyní parsuje nový odlehčený skener řetězců, který zcela nahrazuje DOMDocument. Zvládá vnořené značky se sledováním hloubky, rekurzivní bloky kontejnerů i kombinovanou syntaxi v jediném průchodu. V testech výkonu zpracuje 1,000 plochých značek za 2.4ms a 100 úrovní vnoření za 3.7ms; je tak trvale rychlejší než DOMDocument i `WP_HTML_Tag_Processor` od WordPress. Stejný parser zpracovává také nezpracované prvky HTML pro [Pages a Patterns](https://blockstudio.dev/cs/docs/pages-and-patterns/) a nahrazuje parser založený na DOMDocument, který dříve zpracovával prvky `<p>`, `<div>` a další HTML.

## Nové typy polí

### Blok

Nový typ pole `block` umožňuje odkazovat na jiný blok Blockstudio jako na atribut. Pole odkazovaného bloku se rozbalí přímo pomocí `idStructure` a `overrides`, stejně jako vlastní pole. Rozdíl je v tom, že přístup k hodnotě v šabloně vrátí vykreslený výstup bloku.

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

Pokud má `mytheme/card` pole `heading` a `content`, hostitelský blok získá na postranním panelu `card_heading` a `card_content`. V šabloně `{{ a.card }}` vypíše vykreslenou kartu. Funguje s běžnými bloky i komponentami.

### Značka HTML

Každé téma obsahuje bloky, u kterých se má úroveň nadpisu měnit podle kontextu. Na domovské stránce H1, na vnitřních stránkách H2. Namísto toho, abyste pokaždé vytvářeli výběrové pole s pevně danými možnostmi, je nyní k dispozici samostatný typ pole `html-tag` s přednastavenými hodnotami.

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

Předvolby: `heading` (h1–h6), `text` (nadpisy + p, span, div), `structural` (div, section, article, aside, main, header, footer, nav), `all`. Lze předat i vlastní pole. `exclude` odebere konkrétní značky z libovolné předvolby.

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

## Databáze

Tohle je hlavní novinka tohoto vydání. Přidejte do libovolné složky bloku soubor `db.php` a Blockstudio vytvoří pět koncových bodů REST CRUD, ověří každý zápis podle schématu, automaticky spravuje úložiště a poskytne klienta JavaScript (`bs.db()`) i PHP API (`Db::get()`). Žádné migrační soubory, třídy kontrolerů ani registrace tras.

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

Už samotné toto schéma vytvoří plně funkční API s koncovými body pro vytváření, výpis, načítání, aktualizaci a mazání, všechny s ověřováním vstupu.

### Úložiště

Pět úložišť, každé vhodné pro jiné použití:

- **`table`**: Vlastní tabulka MySQL spravovaná pomocí `dbDelta()`. Přidání polí do schématu přidá sloupce při příštím načtení stránky. Výchozí nastavení pro produkční prostředí.
- **`sqlite`**: Jeden soubor SQLite ve složce bloku `db/`. Skutečné dotazy SQL, režim WAL pro souběžné čtení a plná přenositelnost. Zkopírujte složku, zkopírujte databázi.
- **`jsonc`**: Jeden objekt JSON na řádek v plochém souboru. Čitelný pro lidi, s možností správy verzí a přátelský k git.
- **`meta`**: Pole JSON v metadatech příspěvku WordPress, navázané na konkrétní příspěvek.
- **`post_type`**: Každý záznam se stane příspěvkem WordPress ve vlastním typu příspěvku. Pole se ukládají jako samostatné položky metadat příspěvku a lze je plně dotazovat pomocí `WP_Query`.

### Klienti

Na straně JavaScript vám `bs.db()` poskytne kompletní klient CRUD:

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

Součástí jsou také tři doprovodné nástroje:

- **`bs.cache`**: Mezipaměť dotazů v paměti s funkcemi `get`, `set`, `invalidate` a `clear`. Sdílí se napříč všemi voláními dotazů a mutací.
- **`bs.query(key, fn, options)`**: Obalí libovolnou asynchronní funkci ukládáním do mezipaměti, deduplikací požadavků a nastavitelným `staleTime`. Více volání se stejným klíčem během probíhajícího požadavku vrátí stejný příslib.
- **`bs.mutate(options)`**: Zpracovává optimistické mutace s automatickým vrácením změn. Předávejte reaktivní stavový objekt, akci (`create`, `update`, `delete`) a optimistická data. UI se aktualizuje okamžitě. Pokud volání serveru selže, stav se vrátí ke snímku před mutací.

Dohromady pokrývají celý cyklus čtení a zápisu: `bs.query` pro čtení z mezipaměti, `bs.mutate` pro optimistické zápisy a `bs.cache` pro ruční řízení.

Na straně PHP poskytuje třída `Db` stejné operace:

```php
use Blockstudio\Db;

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

### Ověřování

Chyby ověřování se vracejí jako pole chyb pro jednotlivá pole, inspirovaná formátem `fieldErrors` od Zod. U jednoho pole může selhat více pravidel a struktura usnadňuje přiřazení chyb k polím formuláře na frontendu:

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

Vlastní zpětná volání `validate` se spouštějí na straně serveru pro případy, které vestavěná pravidla nepokryjí: blokování domén, ověřování napříč poli nebo externí vyhledávání.

### Data pro konkrétního uživatele

U dat pro jednotlivé uživatele, jako jsou úkoly, oblíbené položky nebo koncepty, nastavte `userScoped` na `true` a Blockstudio se postará o zbytek. Přidá sloupec `user_id`, automaticky ho nastaví při vytvoření a každý dotaz omezí na aktuálního uživatele. U aktualizací a mazání ověřuje vlastnictví. Žádné ruční pole `user_id`, žádný hook `before_create`, žádné filtrování v RPC. Stačí jeden řádek konfigurace. Při použití úložiště `post_type` se `userScoped` mapuje na `post_author` namísto samostatného sloupce.

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

### Průběžné dotazování

Nastavte ve schématu `'realtime' => true` a klient začne automaticky vyhledávat změny. Když se na serveru něco změní, úložiště Interactivity API se aktualizuje a UI se znovu vykreslí, aniž byste museli cokoli měnit v JavaScript. Vlastní klíče stavu a intervaly nastavíte pomocí `'realtime' => ['key' => 'todos', 'interval' => 5000]`. Dotazování používá porovnávání hashů, aby byly požadavky úsporné, a pozastaví se, když je karta prohlížeče skrytá.

### Zabezpečení, hooky a přenositelnost

Veřejné koncové body jsou chráněny automaticky vloženou hlavičkou CSRF `X-BS-Token`. Pokud potřebujete přístup zcela bez ověřování, například pro příchozí webhooky, použijte `'open'`.

Hooky životního cyklu se spouštějí před každou operací zápisu i po ní. Definujte je přímo v `db.php` nebo globálně pomocí akcí WordPress.

Pole mohou definovat klíč `component` pro vykreslování formulářů podle schématu prostřednictvím `bs_db_form()`.

Při použití úložiště SQLite nebo JSONC je celá aplikace v jedné složce: kód, logika, řízení přístupu i data. Nasazení provedete zkopírováním složky.

## RPC

Někdy CRUD nestačí. Potřebujete vlastní logiku na serveru, například přepnutí úkolu, odeslání oznámení nebo souhrn statistik. K tomu slouží `rpc.php`. Definujte funkci PHP, zavolejte ji z frontendu pomocí `bs.fn()` a Blockstudio se postará o koncový bod REST, ověřování, ochranu CSRF a serializaci JSON. Tento přístup vychází z [tRPC](https://trpc.io): procedury se definují na serveru a klient je volá podle názvu.

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

Vložené skripty (`script-inline.js`) automaticky zjistí název bloku z atributu `data-block` značky skriptu, takže ho nemusíte předávat ručně. Skripty modulů ho předávají jako třetí argument.

Možnosti řízení přístupu zahrnují `public` (s CSRF), `'open'` (bez ochrany), řetězce oprávnění nebo pole. Podporováno je také řízení metody HTTP pro jednotlivé funkce, hooky životního cyklu a volání napříč bloky z JS i PHP.

## Cron

Úlohy na pozadí se definují v souboru `cron.php`. Nastavte plán a zpětné volání a Blockstudio je při inicializaci zaregistruje do WordPress Cron. Při deaktivaci pluginu se všechny úlohy řádně zruší.

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

Podporovány jsou všechny vestavěné plány WordPress i vlastní intervaly prostřednictvím filtru `cron_schedules`.

## CLI

Nový příkaz `wp bs` pokrývá celou sadu funkcí Blockstudio: bloky, databázi, RPC, cron, nastavení, kompilaci Tailwind, kompilaci SCSS, vlastní pole a správu prostředků.

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

Všechny příkazy podporují `--format=json` pro skriptování.

## Vylepšení opakovače

### textMinimized pro pole objektů

Sbalené řádky opakovače nyní správně zpracovávají hodnoty polí objektů. Dříve se při nastavení `textMinimized` na odkazové pole zobrazovalo `[object Object]`. Nyní Blockstudio automaticky načte správnou podvlastnost podle typu pole: `title` u odkazů, `value` u barev a přechodů, `icon` u ikon. Můžete také nastavit výslovnou vlastnost `key` a načíst libovolnou podvlastnost.

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

### RichText a MediaPlaceholder

Obě komponenty šablon nyní fungují uvnitř polí opakovače a pomocí hranaté notace cílí na správný řádek. V každém řádku opakovače lze přímo upravovat nadpisy a odstavce i nahrávat média.

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

## Podmínky vlastních polí s idStructure

Pokud vlastní pole používá `idStructure`, ID podmínek v definici pole se nyní automaticky přepíší tak, aby odpovídala rozbaleným názvům. Jestliže má skupina polí velikosti písma podmínku pro `enable` a rozbalíte ji pomocí `idStructure: "title_font_{id}"`, podmínka nyní správně odkazuje na `title_font_enable` místo původního `enable`.

Podporovány jsou také podmínky na úrovni odkazu. Přidejte `conditions` k odkazu na vlastní pole a podmínky se použijí na všechna rozbalená pole najednou.

## Dynamické argumenty populate

Argumenty populate nyní mohou pomocí syntaxe `{attributes.*}` odkazovat na další atributy bloku. Když se odkazovaný atribut změní, výběrové pole automaticky znovu načte své možnosti. Propojte výběrová pole: jedno pro výběr typu příspěvku a další pro načtení příspěvků daného typu.

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

Změňte `post_type` na „page“ a druhé výběrové pole načte stránky. Změňte ho na „post“ a načte příspěvky. Funguje s libovolným typem populate i libovolným atributem.

## Composer

Blockstudio nyní funguje při načtení odkudkoli pod `wp-content/`, nejen z adresáře pluginů. Adresy URL prostředků se určují pomocí konstanty `BLOCKSTUDIO_URL` namísto `plugins_url()`, takže instalace přibalené k tématu fungují ihned:

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

Závislosti `composer.json` potřebné za běhu byly upraveny. Vymezené balíčky (TailwindPHP, ScssPhp, Minify), které už jsou součástí `lib/`, se v závislostech potřebných za běhu již neuvádějí. Zůstávají pouze `php >= 8.2` a `plugin-update-checker`.

Všechny tři způsoby instalace (ZIP pluginu, plugin přes Composer, přibalení k tématu přes Composer) se spustí se stejným výsledkem: plná aktivace WordPress, registrace bloků a vykreslování frontendu.

Pokyny k nastavení najdete v [dokumentaci Composer](https://blockstudio.dev/cs/docs/dev/composer/).

## Profiler výkonu

Přidejte `?blockstudio-perf` na libovolnou stránku URL a dole se zobrazí ladicí panel s dobou vykreslování jednotlivých bloků, rozpisem fází a mírou zásahů do mezipaměti. Časové údaje se také odesílají v hlavičkách Server-Timing a zobrazují se na kartě Network v DevTools prohlížeče.

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

Trvalé profilování každého načtení stránky zapnete v nastavení. Zobrazí se pouze přihlášeným uživatelům s oprávněním `edit_posts`.

V paměti se nyní ukládají také značky bloků bez uzavírací značky. Když se na stránce stejný blok se stejnými atributy objeví vícekrát, při dalších vykresleních se přeskočí celý proces vykreslování šablony.

## Opravy chyb

- **Upozornění na zastaralé funkce v PHP 8.4**: Opravena upozornění na zastaralé funkce `strpos()` a `str_replace()` způsobená předáváním `null` do `add_submenu_page()`.

## Další informace

- **Pole kódu SCSS**: Pole kódu podporují `language: "scss"`. Hodnoty se kompilují přes ScssPhp v editoru i na frontendu.
- **Standardní bloky WordPress**: Adresáře Blockstudio mohou vedle bloků Blockstudio obsahovat také výstup `@wordpress/create-block`. Registrují se automaticky bez samostatného kódu pluginu.

---

Chcete-li vidět full-stack přístup v praxi, průvodce [Full-Stack Blocks](https://blockstudio.dev/cs/guides/full-stack-blocks/) vás provede vytvořením aplikace se seznamem úkolů pro jednotlivé uživatele a veřejným formulářem pro přihlášení k odběru newsletteru od začátku.
