
Blockstudio 7.1 je prvým vydaním s novými funkciami od prepisu v7. Kým v7
prebudovalo základy, verzia 7.1 pridáva prvky, ktoré menia bloky na niečo viac:
vrstvu databázy, serverové funkcie, plánované úlohy a CLI. Priečinok bloku
teraz môže byť kompletnou aplikáciou.

Tu je všetko nové.

## Komponenty

Vždy existovalo napätie medzi blokmi, ktoré používatelia editora vkladajú
pomocou vkladacieho panela, a blokmi, ktoré vývojári používajú ako stavebné prvky
pre ďalšie veci. Karta, odznak, štatistický widget, vstupné pole formulára.
Potrebujú celý proces Blockstudio (atribúty, šablóny, zdroje, Tailwind), ale
nemajú sa zobrazovať vo vkladacom paneli.

Verzia 7.1 tento problém rieši zavedením komponentov. Nastavte `"component": true` vo svojom
block.json a blok prejde celým procesom zostavenia, ale nezaregistruje sa v registri
typov blokov WordPress. Nezobrazí sa vo vkladacom paneli ani v údajoch editora
odosielaných do JavaScript, no bude plne dostupný na programové vykresľovanie.

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

Vykreslite ich z PHP:

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

Alebo použite novú syntax značiek HTML:

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

## Značky blokov

Bloky teraz možno vkladať ako značky HTML pomocou dvoch vzájomne zameniteľných zápisov:

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

Oba zápisy vytvoria rovnaký výstup. Fungujú s blokmi Blockstudio aj so základnými
blokmi WordPress. V šablónach blokov sa vykreslia automaticky bez potreby čokoľvek
povoliť. Celé rozloženia tak môžete skladať priamo v šablóne z iných blokov:

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

Tieto dva zápisy možno ľubovoľne vnorovať. Bloky Blockstudio sa vykresľujú cez celý
proces (šablóny, Tailwind, zdroje). Základné bloky sa vykresľujú cez WordPress
pomocou rovnakých vykresľovačov, ktoré poháňajú [Stránky a vzory](https://blockstudio.dev/sk/docs/pages-and-patterns/).

Ak chcete vykresľovať na úrovni stránky (obsah príspevku, oblasti widgetov), povoľte to v
`blockstudio.json`:

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

Zoznamy povolených a zakázaných blokov určujú, ktoré bloky možno vykresliť
pomocou značiek; podporujú zástupné vzory. Atribúty `data-*` a `html-*` sa
prenášajú do koreňového prvku HTML vykresleného bloku. Vlastné vykresľovače
možno zaregistrovať pomocou filtra `blockstudio/block_tags/renderers`.

Pod kapotou parser značiek tvorí nový ľahký skener reťazcov, ktorý úplne
nahrádza DOMDocument. Spracúva vnorené značky so sledovaním hĺbky, rekurzívne
kontajnerové bloky a zmiešanú syntax v jednom prechode. V testoch spracuje
1,000 plochých značiek za 2.4ms a 100 úrovní vnorenia za 3.7ms,
pričom je sústavne rýchlejší než DOMDocument aj WordPress a jeho `WP_HTML_Tag_Processor`.
Ten istý parser spracúva aj značky surových prvkov HTML pre
[Stránky a vzory](https://blockstudio.dev/sk/docs/pages-and-patterns/) a nahrádza parser založený na DOMDocument,
ktorý predtým spracúval prvky `<p>`, `<div>` a ďalšie prvky HTML.

## Nové typy polí

### Blok

Nový typ poľa `block` umožňuje odkazovať na iný blok Blockstudio ako na atribút.
Polia odkazovaného bloku sa vložia priamo pomocou `idStructure` a `overrides`,
rovnako ako vlastné polia. Rozdiel je v tom, že prístup k hodnote v šablóne
vráti vykreslený výstup bloku.

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

Ak má `mytheme/card` polia `heading` a `content`, hostiteľský blok zobrazí na bočnom
paneli položky `card_heading` a `card_content`. V šablóne `{{ a.card }}` vygeneruje vykreslenú kartu.
Funguje s bežnými blokmi aj komponentmi.

### Značka HTML

Každá téma obsahuje bloky, pri ktorých sa úroveň nadpisu mení podľa kontextu.
Na domovskej stránke je to H1, na vnútorných stránkach H2. Namiesto toho, aby ste
ju zakaždým nastavovali pomocou výberového poľa s pevne určenými možnosťami,
máte teraz k dispozícii samostatný typ poľa `html-tag` so vstavanými predvoľbami.

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

Predvoľby: `heading` (h1-h6), `text` (nadpisy + p, span, div), `structural`
(div, section, article, aside, main, header, footer, nav), `all`. Môžete
zadať aj vlastné pole. `exclude` odstráni konkrétne značky z ktorejkoľvek predvoľby.

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

## Databáza

Toto je ústredná novinka tohto vydania. Pridajte do ľubovoľného priečinka bloku
súbor `db.php` a Blockstudio vygeneruje päť koncových bodov REST CRUD, overí každý
zápis podľa schémy, automaticky spravuje úložisko a poskytne klienta JavaScript
(`bs.db()`) aj PHP API (`Db::get()`). Žiadne migračné súbory, triedy
kontrolérov ani registrácia trás.

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

Samotná táto schéma vytvorí plne funkčný API s koncovými bodmi na vytváranie,
výpis, získanie, aktualizáciu a odstránenie záznamov, pričom každý z nich
overuje vstupné údaje.

### Úložisko

Päť typov úložísk pre rôzne prípady použitia:

- **`table`**: Vlastná tabuľka MySQL spravovaná cez `dbDelta()`. Pridaním polí do
  schémy sa pri ďalšom načítaní stránky pridajú stĺpce. Predvolená možnosť pre produkčné prostredie.
- **`sqlite`**: Jeden súbor SQLite v priečinku `db/` bloku. Skutočné dotazy SQL,
  režim WAL pre súbežné čítanie a úplná prenositeľnosť. Skopírujte priečinok a databázu.
- **`jsonc`**: Jeden objekt JSON na riadok v plochom súbore. Ľahko čitateľný,
  s možnosťou správy verzií a vhodný pre git.
- **`meta`**: Pole JSON v metadátach príspevku WordPress, viazané na konkrétny príspevok.
- **`post_type`**: Každý záznam sa uloží ako príspevok WordPress vo vlastnom type príspevku.
  Polia sa ukladajú ako samostatné položky metaúdajov príspevku a možno v nich
  vyhľadávať pomocou `WP_Query`.

### Klienti

Na strane JavaScript vám `bs.db()` poskytne kompletného klienta 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);
```

Súčasťou balíka sú aj tri pomocné nástroje:

- **`bs.cache`**: Medzipamäť dotazov v pamäti s funkciami `get`, `set`, `invalidate`
  a `clear`. Zdieľa sa medzi všetkými volaniami dotazov a mutácií.
- **`bs.query(key, fn, options)`**: Obalí ľubovoľnú asynchrónnu funkciu a pridá jej ukladanie do
  medzipamäte, zlučovanie duplicitných požiadaviek a nastaviteľné `staleTime`.
  Viaceré volania s rovnakým kľúčom počas prebiehajúcej požiadavky vrátia
  rovnaký prísľub.
- **`bs.mutate(options)`**: Spracúva optimistické mutácie s automatickým vrátením zmien.
  Zadajte reaktívny stavový objekt, akciu (`create`, `update`, `delete`) a
  optimistické údaje. UI sa aktualizuje okamžite. Ak volanie servera zlyhá,
  stav sa obnoví na snímku spred mutácie.

Spolu pokrývajú celý cyklus čítania a zápisu: `bs.query` na čítanie z medzipamäte,
`bs.mutate` na optimistické zápisy a `bs.cache` na manuálne ovládanie.

Na strane PHP poskytuje trieda `Db` rovnaké operácie:

```php
use Blockstudio\Db;

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

### Overovanie

Chyby pri overovaní sa vracajú ako polia chýb pre jednotlivé polia, podľa vzoru
formátu `fieldErrors` od Zod. Pri jednom poli môže zlyhať viacero pravidiel a
vďaka tejto štruktúre možno chyby jednoducho priradiť k poliam formulára
na frontende:

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

Vlastné spätné volania `validate` sa spúšťajú na serveri pri overovaní všetkého,
čo nepokrývajú vstavané pravidlá: blokovanie domén, overovanie medzi poľami
alebo externé vyhľadávanie.

### Údaje pre jednotlivých používateľov

Pri údajoch pre konkrétneho používateľa, napríklad zoznamoch úloh, obľúbených
položkách alebo konceptoch, nastavte `userScoped` na `true` a o zvyšok sa postará
Blockstudio. Pridá stĺpec `user_id`, pri vytváraní ho automaticky vyplní a každý dotaz
obmedzí na aktuálneho používateľa. Pri aktualizácii a odstránení overí vlastníctvo.
Nemusíte ručne pridávať pole `user_id` ani háčik `before_create` či filtrovanie v RPC.
Stačí jeden riadok konfigurácie. Pri úložisku `post_type` sa `userScoped` namiesto
samostatného stĺpca mapuje na `post_author`.

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

### Priebežné zisťovanie zmien

Nastavte vo svojej schéme `'realtime' => true` a klient bude automaticky zisťovať zmeny.
Keď sa na serveri niečo zmení, úložisko Interactivity API sa aktualizuje
a UI sa znova vykreslí bez akýchkoľvek zmien v JavaScript. Pomocou `'realtime' => ['key' => 'todos', 'interval' => 5000]`
nastavíte vlastné stavové kľúče a intervaly. Na obmedzenie prenosu sa pri
zisťovaní zmien porovnávajú haše; po skrytí karty prehliadača sa pozastaví.

### Zabezpečenie, háčiky a prenositeľnosť

Verejné koncové body sú chránené automaticky vloženou hlavičkou CSRF `X-BS-Token`.
Ak potrebujete prístup úplne bez overenia, napríklad pre prichádzajúce webhooky,
použite `'open'`.

Háčiky životného cyklu sa spúšťajú pred každou operáciou zápisu aj po nej.
Definujte ich priamo v `db.php` alebo globálne pomocou akcií WordPress.

V poliach možno definovať kľúč `component` na vykresľovanie formulárov podľa schémy
pomocou `bs_db_form()`.

Pri použití úložiska SQLite alebo JSONC sa celá aplikácia nachádza v jednom
priečinku: kód, logika, riadenie prístupu aj údaje. Nasadenie stačí vykonať skopírovaním priečinka.

## RPC

Niekedy CRUD nestačí. Potrebujete vlastnú logiku na serveri, napríklad zmenu
stavu úlohy, odoslanie upozornenia alebo agregáciu štatistík. Na to slúži `rpc.php`.
Definujte funkciu PHP, zavolajte ju z frontendu pomocou `bs.fn()` a Blockstudio
sa postará o koncový bod REST, overovanie, ochranu CSRF a serializáciu JSON.
Tento prístup vychádza z [tRPC](https://trpc.io): procedúry sa definujú na serveri
a klient ich volá podľa 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 zistia názov bloku z atribútu `data-block`
svojej značky skriptu, takže ho nemusíte zadávať ručne. Modulové skripty ho
prijímajú ako tretí argument.

Možnosti riadenia prístupu zahŕňajú `public` (s ochranou CSRF), `'open'` (bez
ochrany), reťazce oprávnení alebo polia. Podporované je aj riadenie metód HTTP
pre jednotlivé funkcie, háčiky životného cyklu a volania medzi blokmi z prostredia
JS aj PHP.

## Cron

Úlohy na pozadí sa definujú v súbore `cron.php`. Nastavte plán a spätné volanie
a Blockstudio ich pri inicializácii zaregistruje v WordPress Cron. Po deaktivácii
doplnku sa všetky naplánované úlohy správne odstránia.

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

Podporované sú všetky vstavané plány WordPress, ako aj vlastné intervaly cez
filter `cron_schedules`.

## CLI

Nový príkaz `wp bs` pokrýva celú sadu funkcií Blockstudio: bloky,
databázu, RPC, cron, nastavenia, kompiláciu Tailwind, kompiláciu SCSS,
vlastné polia a správu zdrojov.

```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šetky príkazy podporujú `--format=json` na použitie v skriptoch.

## Vylepšenia opakovača

### textMinimized pre polia objektov

Zbalené riadky opakovača teraz správne spracúvajú hodnoty polí objektov.
Predtým sa pri nastavení `textMinimized` na pole odkazu zobrazilo `[object Object]`.
Teraz Blockstudio automaticky načíta správnu podvlastnosť podľa typu poľa:
`title` pre odkazy, `value` pre farby a prechody a `icon` pre ikony.
Môžete nastaviť aj explicitnú vlastnosť `key` a načítať ľubovoľnú podvlastnosť.

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

### RichText a MediaPlaceholder

Oba komponenty šablón teraz fungujú aj v poliach opakovača a pomocou zápisu
v hranatých zátvorkách možno zacieliť na správny riadok. V každom riadku
opakovača tak môžete upravovať nadpisy a odseky priamo v texte a nahrávať
súbory do oblastí na vkladanie médií.

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

## Podmienky vlastných polí s idStructure

Pri použití vlastného poľa s `idStructure` sa ID podmienok v definícii poľa
teraz automaticky prepíšu tak, aby zodpovedali rozšíreným názvom. Ak má skupina
polí veľkosti písma podmienku pre `enable` a rozšírite ju pomocou `idStructure: "title_font_{id}"`,
podmienka teraz správne odkazuje na `title_font_enable` namiesto pôvodného `enable`.

Podporované sú aj podmienky na úrovni odkazu. Pridaním `conditions` k odkazu
na vlastné pole použijete podmienky naraz na všetky rozšírené polia.

## Dynamické argumenty vyplnenia

Argumenty vyplnenia môžu teraz pomocou syntaxe `{attributes.*}` odkazovať na ďalšie
atribúty bloku. Keď sa odkazovaný atribút zmení, možnosti výberového poľa sa
automaticky načítajú znova. Prepojte výberové polia: jedno na výber typu
príspevku a druhé na načítanie príspevkov daného typu.

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

Zmeňte `post_type` na „page“ a druhé výberové pole načíta stránky. Zmeňte ho na
„post“ a načíta príspevky. Funguje s ľubovoľným typom vyplnenia a atribútom.

## Composer

Blockstudio teraz funguje pri načítaní z ľubovoľného umiestnenia v rámci `wp-content/`,
nielen z priečinka doplnkov. Adresy URL zdrojov sa určujú pomocou konštanty
`BLOCKSTUDIO_URL` namiesto `plugins_url()`, takže inštalácia priamo v téme funguje ihneď:

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

Závislosti `composer.json` potrebné za behu boli upratané. Balíky v rozsahu
(TailwindPHP, ScssPhp, Minify), ktoré sú už súčasťou `lib/`, sa už neuvádzajú
medzi závislosťami potrebnými za behu. Zostali len `php >= 8.2` a `plugin-update-checker`.

Všetky tri spôsoby inštalácie (archív doplnku ZIP, doplnok cez Composer,
téma s integrovaným Composer) vedú k rovnakému výsledku: plnej aktivácii WordPress,
registrácii blokov a vykresľovaniu na frontende.

Pokyny na nastavenie nájdete v dokumentácii [Composer](https://blockstudio.dev/sk/docs/dev/composer/).

## Profiler výkonu

Pridajte `?blockstudio-perf` na ľubovoľnú stránku URL a v dolnej časti sa zobrazí
panel ladenia s časmi vykresľovania jednotlivých blokov, rozpisom fáz a mierou
zásahov do vyrovnávacej pamäte. Údaje o časovaní sa odosielajú aj v hlavičkách
Server-Timing a sú viditeľné na karte Sieť v nástrojoch pre vývojárov prehliadača.

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

Povoľte ho natrvalo v nastaveniach, aby profiloval každé načítanie stránky.
Zobrazuje sa iba prihláseným používateľom s oprávnením `edit_posts`.

Značky blokov bez párového ukončenia sa teraz ukladajú do pamäte. Ak sa na
stránke viackrát objaví ten istý blok s rovnakými atribútmi, pri ďalších
vykresleniach sa preskočí celý proces spracovania šablóny.

## Opravy chýb

- **Upozornenia na zastarané funkcie v PHP 8.4**: Opravené upozornenia na zastarané funkcie `strpos()` a `str_replace()` spôsobené odovzdaním `null` do `add_submenu_page()`.

## Ďalšie

- **Polia kódu SCSS**: Polia kódu podporujú `language: "scss"`. Hodnoty sa kompilujú cez ScssPhp v editore aj na frontende.
- **Štandardné bloky WordPress**: Priečinky Blockstudio môžu obsahovať výstup `@wordpress/create-block` spolu s blokmi Blockstudio. Zaregistrujú sa automaticky bez samostatného kódu doplnku.

---

Ak chcete vidieť celý proces tvorby aplikácie s frontendovou aj backendovou časťou,
sprievodca [Bloky s frontendovou aj backendovou časťou](https://blockstudio.dev/sk/guides/full-stack-blocks/) vás krok za krokom
prevedie vytvorením aplikácie so zoznamom úloh pre jednotlivých používateľov a
verejným formulárom na prihlásenie k odberu noviniek.
