
Blockstudio 7.2 extinde cadrul în două direcții simultan.

Prima ține de **vizibilitate și fluxul de lucru** în cadrul unui singur proiect: o nouă prezentare generală în panoul de administrare, un explorator de baze de date, un explorator al registrului din panoul de administrare și preambuluri SCSS pentru configurarea partajată Sass.

A doua ține de **ecosistemul din jurul Blockstudio**: un registru CLI pentru distribuirea blocurilor (precum shadcn pentru WordPress) și o extensie PHPStan care aduce șabloanelor siguranța tipurilor în stil TypeScript, etichetelor de bloc, `db.php`, `rpc.php`, `cron.php` și fișierelor de schemă asociate.

Ambele direcții urmăresc același lucru: să faciliteze înțelegerea, extinderea și partajarea proiectelor Blockstudio de mari dimensiuni.

## Experiența de administrare

Două noutăți facilitează navigarea în proiectele mari din wp-admin.

### Prezentare generală în panoul de administrare

Blockstudio include acum un ecran de administrare în **Instrumente > Blockstudio**. Acesta vă oferă un singur loc pentru a inspecta ce a înregistrat sistemul din sistemul de fișiere.

Prezentarea generală include file dedicate pentru:

- Blocuri
- Extensii
- Câmpuri
- Pagini
- Scheme

Pe lângă prezentarea generală, zona de administrare include acum o secțiune dedicată **Bazelor de date**. Aceasta listează fiecare schemă `Blockstudio\Db` înregistrată și vă permite să inspectați înregistrările reale direct în wp-admin.

În loc să construiască o grilă personalizată de panouri, ecranul folosește tabelele native WordPress DataViews. Astfel, UI rămâne aliniat cu wp-admin și devine practic atunci când un proiect are zeci sau sute de înregistrări.

Într-o instalare mică, puteți ține în minte starea de execuție. Într-o bază de cod mai mare, acest lucru nu mai funcționează. Încep să apară întrebări precum:

- Ce tipuri de blocuri sunt înregistrate acum?
- Ce extensii vizează `core/*` și care vizează blocuri individuale?
- Ce pagini sunt sincronizate și căror tipuri de articole le aparțin?
- Ce câmpuri reutilizabile există în acest proiect?
- Ce scheme sunt înregistrate și ce backend de stocare folosesc?

Până acum, răspunsul însemna o combinație de răsfoire a dosarelor, deschidere a fișierelor JSON și parcurgere a PHP. Prezentarea generală transformă acest lucru într-o secțiune reală în panoul de administrare.

Fiecare filă este concepută să răspundă la întrebări diferite:

- **Blocuri** afișează tipurile de blocuri înregistrate, modul de redare, versiunea API și numărul de atribute
- **Extensii** arată ce blocuri vizează, împreună cu prioritatea și detaliile redării
- **Câmpuri** oferă un inventar rapid al definițiilor reutilizabile de câmpuri personalizate
- **Pagini** afișează paginile sincronizate din fișiere, împreună cu tipul de articol, starea, motorul de șabloane și starea sincronizării
- **Scheme** prezintă schemele de stocare înregistrate, împreună cu backendul, numărul de câmpuri și domeniul de capabilități

Browserul bazei de date este ținut intenționat separat de conținutul inițial al prezentării generale. În loc să serializeze fiecare rând la încărcarea paginii, acesta localizează din start doar schemele disponibile și preia înregistrările la cerere, când deschideți o filă a bazei de date. Astfel, zona de administrare rămâne utilă chiar și atunci când proiectul are seturi de date mai mari în spatele `db.php`.

Această primă versiune se concentrează intenționat pe înregistrările bazate pe scheme. Nu este o pagină de setări. Este o pagină de inspecție.

Dacă nu îl doriți deloc, dezactivați-l complet:

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

### Browserul registrului din zona de administrare

Alături de prezentarea generală se află o a doua filă: **Registry**. Aceasta este un browser pentru registrele de blocuri la distanță configurate în `blocks.json` din tema dvs. și vă permite să importați blocuri direct din zona de administrare WordPress fără să atingeți un 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}"
      }
    }
  }
}
```

Browserul preia fiecare registru configurat, listează toate blocurile disponibile și arată dacă sunt deja instalate local sau pot fi importate. Fiecare rând are un buton Import, care descarcă fișierele blocului în directorul configurat al temei. Blocurile deja instalate au în schimb un buton Reimport.

Registrele autentificate sunt acceptate prin formatul obiect cu `headers`, inclusiv interpolarea `${ENV_VAR}`, astfel încât tokenurile să nu ajungă niciodată în controlul versiunilor.

Astfel, navigarea și utilizarea registrelor devin o experiență de prim rang în zona de administrare, nu doar un flux de lucru CLI.

## Registry CLI

Cealaltă componentă a registrelor este un CLI autonom: `blockstudio/registry`.

Este un instrument în stil shadcn pentru blocuri WordPress. Fără pachet npm, fără etapă de compilare. Rulați o comandă, codul sursă al blocului este copiat în proiectul dvs., iar acesta vă aparține în totalitate.

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

CLI funcționează cu orice tip de bloc: blocuri Blockstudio, rezultat `@wordpress/create-block`, blocuri PHP obișnuite. Registrul nu ține cont de ce se află în dosar. Citește manifestul fișierelor din `registry.json` și copiază exact acele fișiere.

Autorii de blocuri publică un `registry.json` la orice URL (conținut brut GitHub, S3, un server personalizat) care listează blocurile disponibile, împreună cu metadate, dependențe și liste de fișiere. Utilizatorii adaugă URL la `blocks.json` și preiau blocuri după nume.

CLI acceptă:

- **Rezolvarea dependențelor**: blocurile pot declara dependențe de alte blocuri, rezolvate automat cu detectarea ciclurilor
- **Gestionarea conflictelor între mai multe registre**: când același nume de bloc există în mai multe registre, CLI vă cere să alegeți unul
- **Registre autentificate**: tokenuri bearer, autentificare de bază și antete personalizate cu interpolarea variabilelor de mediu
- **TUI interactivă**: creată cu Ink, cu indicatoare de progres, solicitări de selecție și bare de progres
- **Mod neinteractiv**: indicatorul `--yes` și revenire automată pentru CI/fluxuri redirecționate
- **Căutare și listare**: explorați registrele din linia de comandă

Pachetul include teste 130 care acoperă schemele, rezolvarea dependențelor, preluarea HTTP, scrierea fișierelor, fiecare flux de comandă și UI interactivă Ink.

Documentația completă este la [blockstudio.dev/registry](https://blockstudio.dev/ro/registry/).

## Extensia PHPStan

Cealaltă noutate majoră este `blockstudio/phpstan`: o extensie PHPStan care oferă utilizatorilor Blockstudio siguranța tipurilor la care se așteaptă dezvoltatorii TypeScript.

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

Extensia citește schemele reale ale proiectului în timpul analizei și transmite tipurile rezultate înapoi către PHPStan. Acum sunt acoperite șabloanele PHP, Twig, Blade, etichetele blocurilor, înregistrările tipizate din baza de date, căile setărilor, numele hookurilor și validarea schemelor pentru `block.json`, `field.json`, JSON de extensie, `page.json`, `db.php`, `rpc.php`, `cron.php` și `blockstudio.json`.

### Șabloane de blocuri cu tipuri sigure

Accesările câmpurilor pe `$a` sunt validate în raport cu `block.json` asociată:

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

### Înregistrări tipizate în baza de date

`Db::get()` returnează o instanță tipizată pe baza schemei `db.php`. Structura înregistrării este construită din câmpurile reale:

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

### Validarea schemei

Fișierele de schemă nevalide sunt detectate în timpul analizei: `block.json`, `field.json`, JSON de extensie, `page.json`, `db.php`, `rpc.php`, `cron.php` și `blockstudio.json`. Nume lipsă, tipuri de câmp greșite, definiții malformate, valori booleene prescurtate depreciate (`"tailwind": true` în locul obiectului imbricat) — toate sunt raportate împreună cu linia exactă din fișierul sursă.

### Validarea căilor setărilor

Apelurile `Settings::get()` sunt validate în raport cu schema cunoscută a setărilor:

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

### Validarea numelor hookurilor

La fel și numele hookurilor de filtrare și de acțiune:

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

Extensia include și definiții stub pentru întregul Blockstudio public API: `Db`, `Settings`, `Field_Registry`, `Build` și funcțiile globale auxiliare. Beneficiați de completare automată și verificarea tipurilor pentru toate API-urile Blockstudio, fără să aveți nevoie de sursa pluginului pe mașina de dezvoltare.

## Facilități pentru dezvoltare

Două facilități mai mici pentru dezvoltare completează această versiune.

### Preludii globale SCSS

Blockstudio accepta deja compilarea SCSS, dar exista un inconvenient: configurarea Sass partajată.

Dacă voiați să accesați un set comun de variabile, funcții sau mixinuri, trebuia să le importați în fiecare fișier SCSS. Acest lucru devine rapid repetitiv, mai ales în cazul sistemelor de design mai mari sau al seturilor de instrumente Sass precum Bootstrap.

Versiunea 7.2 adaugă un hook de prelude exact pentru acest scop:

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

Împreună cu filtrul `blockstudio/assets/process/scss/import_paths` existent, definiți o suprafață Sass partajată o singură dată, disponibilă apoi în fiecare fișier compilat.

Foaia de stil a unui bloc se poate concentra pe stilurile de care are nevoie:

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

Fără importuri repetate în fiecare resursă a blocului. Nu este un „suport pentru Bootstrap” într-un mod special. Este un hook generic pentru Sass partajate în tot proiectul, indiferent dacă provin din Bootstrap sau din propriul set intern de instrumente.

### Definiții API pentru blocuri native PHP

Versiunea 7.2 adaugă și o sintaxă opțională nativă PHP pentru API-urile full-stack ale blocurilor. Tablourile rămân formatul implicit și sunt acceptate în continuare pe deplin. Nu s-a înlocuit nimic. Dar dacă preferați argumente numite, enumerații și atribute în locul tablourilor de configurare imbricate, acum puteți opta pentru acest stil.

Pentru `rpc.php`, returnați un obiect cu metode decorate cu atribute:

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

Pentru `cron.php`, aceeași idee funcționează cu `#[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 {
    }
};
```

Iar pentru `db.php` există acum un mic strat de construire:

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

Aceasta oferă un echilibru mai bun pentru bazele de cod mai mari. Păstrați simplitatea formatului cu tablouri când doriți și puteți trece la o suprafață PHP mai ușor de explorat atunci când un bloc depășește câteva câmpuri sau puncte finale.

## De ce sunt lansate împreună aceste funcții

Prezentarea generală din zona de administrare, browserul de registre, CLI pentru registre și extensia PHPStan răspund toate la aceeași întrebare: cum mențineți un proiect Blockstudio ușor de înțeles pe măsură ce crește?

Instrumentele de administrare răspund la nivelul proiectului: vizibilitate asupra celor înregistrate, posibilitatea de a prelua blocuri din registre și mai puține presupuneri.

CLI răspunde la nivelul ecosistemului: o modalitate de a partaja blocuri între proiecte și echipe, fără să le includeți în pachete npm sau să vă luptați cu sistemele de compilare.

Extensia PHPStan răspunde la nivelul codului: detectează accesările incorecte ale câmpurilor, greșelile de scriere din scheme și callbackurile de hook defecte înainte să ajungă în timpul execuției.

Aceasta este direcția generală a versiunii 7.2: mai puține presupuneri și repetiții, vizibilitate mai bună și acum siguranța reală a tipurilor.

## Corecții de erori

- **Câmpul Classes**: numele personalizate de clase introduse de utilizator erau eliminate în tăcere la pierderea focalizării, deoarece validatorul accepta doar clase din lista predefinită Tailwind/de setări. Acum acceptă orice șir nevid.
- **Câmpul Attributes**: eliminarea unei perechi de atribute lăsa în urmă intrări `null` în datele salvate. S-a trecut de la `unset()` din lodash (care înlocuiește cu null elementele tabloului) la `splice()` (care le elimină).
- **Minificatorul CSS**: minificatorul TailwindPHP elimina spațiile albe din jurul lui `+` din `calc()` și `clamp()`, generând CSS invalid, precum `calc(1rem+0.5vw)`. Problema a fost remediată în amonte în TailwindPHP v1.3.1, printr-o parcurgere a caracterelor care ține cont de adâncime și elimină spațiile albe din jurul combinatorilor selectorilor doar la nivelul de paranteze 0.
- **Previzualizarea Block Inserter**: `$isPreview` era întotdeauna `false` în previzualizarea Block Inserter, deoarece cheia hash a cache-ului de randare nu includea modul de randare. Acum, randările din editor și din previzualizare au intrări separate în cache.
- **Șablonul InnerBlocks imbricat**: componenta `<InnerBlocks template="..."/>` elimina al treilea element (copiii) din tuplurile șablonului, precum `['core/group', {}, [['core/paragraph']]]`, generând blocuri container goale. Acum păstrează copiii imbricați.
