
Blockstudio 7.2 rozšiřuje framework dvěma směry současně.

Prvním je **přehled a pracovní postupy** v rámci jednoho projektu: nový přehled pro správce, prohlížeč databází, prohlížeč registru pro správce a úvodní SCSS pro sdílené nastavení Sass.

Druhým je **ekosystém kolem Blockstudio**: registr CLI pro distribuci bloků (podobně jako shadcn pro WordPress) a rozšíření PHPStan, které přináší šablonám, značkám bloků, `db.php`, `rpc.php`, `cron.php` a souvisejícím souborům schémat typovou bezpečnost ve stylu TypeScript.

Oba směry sledují stejný cíl: usnadnit práci s většími projekty Blockstudio, jejich rozšiřování i sdílení.

## Prostředí pro správce

Orientaci ve větším projektu ve wp-admin usnadňují dvě novinky.

### Přehled pro správce

Blockstudio nyní obsahuje obrazovku pro správce v nabídce **Nástroje > Blockstudio**. Na jednom místě můžete zkontrolovat, co systém zaregistroval ze souborového systému.

Přehled obsahuje samostatné karty pro:

- Bloky
- Rozšíření
- Pole
- Stránky
- Schémata

Vedle tohoto přehledu nyní oblast pro správce obsahuje také samostatnou sekci **Databáze**. Zobrazuje každé zaregistrované schéma `Blockstudio\Db` a umožňuje prohlížet skutečné záznamy přímo ve wp-admin.

Obrazovka místo vlastní mřížky panelů používá nativní tabulky DataViews WordPress. Díky tomu je UI v souladu s wp-admin a zůstává praktické i u projektů s desítkami či stovkami registrací.

U malé instalace si můžete její stav snadno udržet v hlavě. U rozsáhlejšího zdrojového kódu to přestává fungovat. Začnete si klást otázky, jako jsou:

- Které bloky jsou právě zaregistrované?
- Která rozšíření cílí na `core/*` a která na jednotlivé bloky?
- Které stránky jsou synchronizované a ke kterým typům příspěvků patří?
- Která opakovaně použitelná pole v projektu existují?
- Která schémata jsou zaregistrovaná a jaké úložiště používají?

Doteď jste odpověď hledali tak, že jste procházeli složky, otevírali soubory JSON a procházeli PHP. Přehled to převádí na skutečné rozhraní pro správce.

Každá karta odpovídá na jiné otázky:

- **Bloky** zobrazují zaregistrované typy bloků, režim vykreslování, verzi API a počet atributů.
- **Rozšíření** ukazují, na které bloky cílí, a uvádějí prioritu a podrobnosti vykreslování.
- **Pole** poskytují rychlý přehled definic opakovaně použitelných vlastních polí.
- **Stránky** zobrazují synchronizované stránky ze souborů včetně typu příspěvku, stavu, šablonovacího systému a stavu synchronizace.
- **Schémata** uvádějí zaregistrovaná schémata úložišť včetně backendu, počtu polí a rozsahu oprávnění.

Prohlížeč databází je záměrně oddělený od úvodního přehledu.
Místo serializace každého řádku při načtení stránky předem načte pouze dostupná schémata a záznamy stahuje na vyžádání, když otevřete kartu databáze. Díky tomu zůstává administrace užitečná i tehdy, když projekt obsahuje větší datové sady za `db.php`.

První verze je záměrně zaměřená na registrace podložené schématy.
Nejde o stránku nastavení. Je to stránka pro kontrolu.

Pokud tuto funkci vůbec nechcete, úplně ji zakažte:

```php
add_filter('blockstudio/admin/enabled', '__return_false');
```

### Prohlížeč registrů v administraci

Vedle přehledu je druhá karta: **Registry**. Slouží k procházení vzdálených registrů bloků nakonfigurovaných v souboru `blocks.json` vaší šablony a umožňuje importovat bloky přímo z administrace WordPress, aniž byste museli sahat na CLI.

```json title="blocks.json"
{
  "directory": "blockstudio",
  "registries": {
    "ui": "https://blocks.example.com/registry.json",
    "private": {
      "url": "https://api.example.com/registry.json",
      "headers": {
        "Authorization": "Bearer ${REGISTRY_TOKEN}"
      }
    }
  }
}
```

Prohlížeč načte každý nakonfigurovaný registr, vypíše všechny dostupné bloky a ukáže, zda jsou už nainstalované lokálně, nebo připravené k importu. Každý řádek obsahuje tlačítko Import, které stáhne soubory bloku do nakonfigurovaného adresáře vaší šablony. U již nainstalovaných bloků se místo něj zobrazí tlačítko Reimport.

Podporovány jsou také ověřené registry ve formátu objektu s `headers`, včetně interpolace `${ENV_VAR}`, takže se tokeny nikdy nedostanou do správy verzí.

Díky tomu je procházení a používání registrů plnohodnotnou součástí administrace, a ne jen pracovním postupem CLI.

## CLI registru

Druhou částí práce s registry je samostatný CLI: `blockstudio/registry`.

Jde o nástroj ve stylu shadcn pro bloky WordPress. Žádný balíček npm ani sestavování.
Spustíte příkaz, zdrojový kód bloku se zkopíruje do vašeho projektu a máte nad ním plnou kontrolu.

```bash
npx blockstudio init
npx blockstudio add ui/tabs
```

CLI funguje s jakýmkoli typem bloku: bloky Blockstudio, výstup `@wordpress/create-block` i běžné bloky PHP. Registru nezáleží na tom, co složka obsahuje. Přečte seznam souborů z `registry.json` a zkopíruje přesně tyto soubory.

Autoři bloků zveřejní `registry.json` na libovolném URL (GitHub surový obsah, S3, vlastní server), kde uvedou dostupné bloky včetně metadat, závislostí a seznamů souborů. Uživatelé přidají URL do svého `blocks.json` a stahují bloky podle názvu.

CLI podporuje:

- **Řešení závislostí**: bloky mohou deklarovat závislosti na jiných blocích; ty se řeší automaticky s detekcí cyklů
- **Řešení konfliktů mezi více registry**: pokud se stejný název bloku vyskytuje ve více registrech, CLI vás vyzve k výběru
- **Ověřené registry**: bearer tokeny, základní ověřování a vlastní hlavičky s interpolací proměnných prostředí
- **Interaktivní TUI**: vytvořené pomocí Ink, s indikátory průběhu, výběrovými výzvami a ukazateli postupu
- **Neinteraktivní režim**: příznak `--yes` a automatické přepnutí při CI nebo přesměrovaném vstupu a výstupu
- **Vyhledávání a výpis**: procházení registrů z příkazového řádku

Balíček obsahuje 130 testů pokrývajících schémata, řešení závislostí, načítání HTTP, zápis souborů, průběh všech příkazů i interaktivní UI v Ink.

Úplná dokumentace je na adrese [blockstudio.dev/registry](https://blockstudio.dev/cs/registry/).

## Rozšíření PHPStan

Dalším velkým přírůstkem je `blockstudio/phpstan`: rozšíření PHPStan, které uživatelům Blockstudio nabízí typovou bezpečnost, jakou očekávají vývojáři TypeScript.

```bash
composer require --dev blockstudio/phpstan
```

Rozšíření při analýze načte skutečná schémata vašeho projektu a předá odvozené typy zpět do PHPStan. Nyní pokrývá šablony PHP, Twig, Blade, značky bloků, typované databázové záznamy, cesty k nastavením, názvy hooků a ověřování schémat v rámci `block.json`, `field.json`, rozšíření JSON, `page.json`, `db.php`, `rpc.php`, `cron.php` a `blockstudio.json`.

### Typově bezpečné šablony bloků

Přístupy k polím v `$a` se ověřují podle sourozeneckého `block.json`:

```php title="blockstudio/hero/index.php"
<?php
/** @var array<string, mixed> $a */

echo $a['title'];     // OK
echo $a['cta']['href']; // OK
echo $a['typo'];      // ERROR: Field "typo" does not exist in block.json (block: hero). Did you mean "title"?
```

### Typované databázové záznamy

`Db::get()` vrací typovanou instanci podle vašeho schématu `db.php`. Struktura záznamu vychází ze skutečných polí:

```php title="db.php"
return [
  'storage' => 'table',
  'fields' => [
    'email' => ['type' => 'string', 'required' => true],
    'name'  => ['type' => 'string'],
  ],
];
```

```php
$db = Db::get('mytheme/subscribers');
$record = $db->create(['email' => 'a@b.com']);

echo $record['email']; // PHPStan: string
echo $record['name'];  // PHPStan: string|null
echo $record['typo'];  // ERROR: Offset 'typo' does not exist on array{id: int, email: string, name: string|null}
```

### Ověřování schémat

Neplatné soubory schémat se zachytí už při analýze: `block.json`, `field.json`, rozšíření JSON, `page.json`, `db.php`, `rpc.php`, `cron.php` a `blockstudio.json`. Chybějící názvy, nesprávné typy polí, chybně utvořené definice i zastaralé zkrácené booleovské hodnoty (`"tailwind": true` místo vnořeného objektu) se hlásí s přesným číslem řádku ve zdrojovém souboru.

### Ověřování cest k nastavením

Volání `Settings::get()` se ověřují podle známého schématu nastavení:

```php
Settings::get('tailwind/enabled');  // OK, returns bool
Settings::get('tailwind/enabld');   // ERROR: Settings path "tailwind/enabld" is not a known Blockstudio setting. Did you mean "tailwind/enabled"?
```

### Ověřování názvů hooků

Totéž platí pro názvy hooků filtrů a akcí:

```php
add_filter('blockstudio/render', $cb);  // OK
add_filter('blockstudio/rendrr', $cb);  // ERROR: Unknown Blockstudio hook "blockstudio/rendrr". Did you mean "blockstudio/render"?
```

Rozšíření obsahuje také definice pro celé veřejné API Blockstudio: `Db`, `Settings`, `Field_Registry`, `Build` a globální pomocné funkce. Získáte našeptávání a kontrolu typů pro všechna rozhraní API Blockstudio, aniž byste na vývojovém počítači potřebovali zdrojový kód pluginu.

## Usnadnění tvorby

Vydání doplňují dvě menší vylepšení pro tvorbu.

### Globální předřazené bloky SCSS

Blockstudio už podporoval kompilaci SCSS, ale měl jednu nepříjemnou slabinu: sdílené nastavení Sass.

Pokud jste chtěli mít k dispozici společnou sadu proměnných, funkcí nebo mixinů, museli jste je importovat do každého souboru SCSS. To se rychle omrzí, zvlášť u rozsáhlejších návrhových systémů nebo sad nástrojů Sass, jako je Bootstrap.

Verze 7.2 přidává hook pro předřazený kód, který tento problém řeší:

```php
add_filter('blockstudio/assets/process/scss/prelude', function($prelude, $path, $scss) {
  return '@import "functions";' . "\n"
    . '@import "variables";' . "\n"
    . '@import "mixins";';
}, 10, 3);
```

Ve spojení se stávajícím filtrem `blockstudio/assets/process/scss/import_paths` jednou definujete společnou sadu Sass a zpřístupní se každému kompilovanému souboru.

Stylopis bloku se tak může soustředit na styly, které skutečně potřebuje:

```scss title="style.scss"
.hero {
  @include media-breakpoint-up(lg) {
    padding: 4rem;
  }
}
```

Už žádné opakované importy v každém souboru bloku. Nejde o zvláštní režim „podpory Bootstrap“. Je to obecný hook pro sdílené Sass v celém projektu, ať už pocházejí z Bootstrap, nebo z vaší vlastní interní sady nástrojů.

### Definice bloků nativní pro PHP API

Verze 7.2 přidává také volitelnou syntaxi nativní pro PHP pro rozhraní API bloků s celým zásobníkem. Pole zůstávají výchozí a plně podporovanou možností. Nic je nenahradilo. Pokud ale dáváte přednost pojmenovaným argumentům, výčtovým typům a atributům před vnořenými konfiguračními poli, můžete nyní zvolit tento styl.

Pro `rpc.php` vraťte objekt s metodami opatřenými atributy:

```php title="rpc.php"
<?php
use Blockstudio\Attributes\Rpc;
use Blockstudio\Rpc\Access;
use Blockstudio\Rpc\Method;

return new class {
    #[Rpc(access: Access::Session)]
    public function subscribe(array $params): array {
        return ['success' => true];
    }

    #[Rpc(name: 'status', methods: [Method::Get, Method::Post])]
    public function getStatus(array $params): array {
        return ['status' => 'ok'];
    }
};
```

U `cron.php` funguje stejný postup s `#[Cron]`:

```php title="cron.php"
<?php
use Blockstudio\Attributes\Cron;
use Blockstudio\Cron\Schedule;

return new class {
    #[Cron(schedule: Schedule::Hourly)]
    public function heartbeat(): void {
    }
};
```

A pro `db.php` je nyní k dispozici jednoduchá vrstva pro sestavení:

```php title="db.php"
<?php
use Blockstudio\Db\Field;
use Blockstudio\Db\Schema;
use Blockstudio\Db\Storage;

return Schema::make(
    storage: Storage::Table,
    fields: [
        'email' => Field::string(required: true, format: 'email'),
        'active' => Field::boolean(default: false),
    ],
);
```

To je pro rozsáhlejší kódové základny vyváženější řešení. Když chcete, zachováte si jednoduchost polí, a když blok překročí několik polí nebo koncových bodů, můžete přejít k přehlednějšímu rozhraní PHP.

## Proč tyto věci vycházejí společně

Přehled v administraci, prohlížeč registrů, CLI registru a rozšíření PHPStan odpovídají na stejnou otázku: jak udržet projekt Blockstudio srozumitelný, i když roste?

Nástroje administrace řeší tuto otázku na úrovni projektu: přinášejí přehled o registrovaných položkách, možnost načítat bloky z registrů a méně prostoru pro dohady.

CLI na ni odpovídá na úrovni ekosystému: umožňuje sdílet bloky mezi projekty a týmy bez jejich balení do balíčků npm nebo potýkání se se sestavovacími systémy.

Rozšíření PHPStan na ni odpovídá na úrovni kódu: zachytí nesprávné přístupy k polím, překlepy ve schématech a nefunkční zpětná volání hooků dřív, než se projeví za běhu.

To je obecný směr verze 7.2: méně dohadů, méně opakování, lepší přehled a nově také skutečná typová bezpečnost.

## Opravy chyb

- **Pole Classes**: Uživatelsky zadané vlastní názvy tříd se při ztrátě fokusu tiše zahazovaly, protože validátor přijímal jen třídy ze seznamu předdefinovaných Tailwind/nastavení. Nyní přijímá libovolný neprázdný řetězec.
- **Pole Attributes**: Po odebrání dvojice atributů zůstávaly v uložených datech položky `null`. Funkce lodash `unset()` (která prvky pole nahrazuje hodnotou null) byla nahrazena funkcí `splice()` (která je odstraní).
- **Minifikátor CSS**: Minifikátor TailwindPHP odstraňoval mezery kolem `+` uvnitř `calc()` a `clamp()`, čímž vytvářel neplatné CSS, například `calc(1rem+0.5vw)`. Oprava byla provedena v upstream projektu TailwindPHP v1.3.1. Prochází znaky s ohledem na hloubku a odstraňuje mezery kolem kombinátorů selektorů pouze při hloubce závorek 0.
- **Náhled v nástroji pro vkládání bloků**: `$isPreview` byl v náhledu tohoto nástroje vždy `false`, protože hash klíč mezipaměti vykreslování nezahrnoval režim vykreslení. Vykreslení editoru a náhledu se nyní ukládají do samostatných položek mezipaměti.
- **Vnořená šablona InnerBlocks**: Komponenta `<InnerBlocks template="..."/>` ze šablonových n-tic, jako je `['core/group', {}, [['core/paragraph']]]`, zahazovala třetí prvek (potomky), což vedlo ke vzniku prázdných bloků kontejnerů. Nyní vnořené potomky zachovává.
