
Blockstudio 7.1 este prima versiune cu funcții noi de la rescrierea v7. Dacă v7 a reconstruit fundația, 7.1 adaugă elementele care transformă blocurile în ceva mai mult: un strat de bază de date, funcții pe server, sarcini programate și un CLI. Un dosar de bloc poate fi acum o aplicație completă.

Iată tot ce este nou.

## Componente

A existat mereu o tensiune între blocurile pe care editorii le folosesc în inserter și blocurile pe care dezvoltatorii le folosesc drept componente de bază pentru alte lucruri. Un card, o insignă, un widget de statistici, un câmp de formular. Acestea au nevoie de întregul flux de Blockstudio (atribute, șabloane, resurse, Tailwind), dar nu au ce căuta în inserter.

Versiunea 7.1 introduce componente pentru a rezolva această problemă. Setați `"component": true` în block.json, iar blocul parcurge întregul flux de compilare, dar nu este niciodată înregistrat în registrul de tipuri de blocuri al WordPress. Nu apare în inserter și nici în datele editorului trimise către JavaScript, dar este disponibil pentru redarea programatică.

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

Redați-le din PHP:

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

Sau folosind noua sintaxă de etichetă HTML:

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

## Etichete de bloc

Blocurile pot fi acum încorporate ca etichete HTML folosind două sintaxe interschimbabile:

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

Ambele produc același rezultat. Ambele funcționează cu blocurile Blockstudio și cu blocurile de bază WordPress. În șabloanele de bloc, sunt redate automat, fără activare explicită. Astfel, puteți compune în șablon machete întregi direct din alte blocuri:

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

Cele două sintaxe se pot imbrica liber una în alta. Blocurile Blockstudio sunt redate prin întregul flux (șabloane, Tailwind, resurse). Blocurile de bază sunt redate prin WordPress folosind aceleași motoare de redare ca [Pagini și modele](https://blockstudio.dev/ro/docs/pages-and-patterns/).

Pentru redarea la nivel de pagină (conținutul articolelor, zonele widgeturilor), activați această opțiune în `blockstudio.json`:

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

Listele de permitere și blocare controlează ce blocuri pot fi redate prin etichete, folosind modele cu metacaractere. Atributele `data-*` și `html-*` sunt transmise elementului rădăcină HTML al blocului redat. Motoarele de redare personalizate pot fi înregistrate prin filtrul `blockstudio/block_tags/renderers`.

În culise, analizatorul de etichete este un nou scanner de șiruri, ușor, care înlocuiește complet DOMDocument. Gestionează etichete imbricate urmărind adâncimea, blocuri container recursive și sintaxă mixtă într-o singură parcurgere. În benchmarkuri, analizează 1,000 etichete plate în 2.4ms și 100 niveluri de imbricare în 3.7ms, fiind constant mai rapid decât DOMDocument și WordPress's `WP_HTML_Tag_Processor`. Același analizator gestionează și analiza elementelor HTML brute pentru [Pagini și modele](https://blockstudio.dev/ro/docs/pages-and-patterns/), înlocuind analizatorul bazat pe DOMDocument care gestiona anterior `<p>`, `<div>` și alte elemente HTML.

## Tipuri noi de câmpuri

### Bloc

Un nou tip de câmp `block` care vă permite să faceți referire la un alt bloc Blockstudio ca atribut. Câmpurile blocului referit se extind inline folosind `idStructure` și `overrides`, exact ca în cazul câmpurilor personalizate. Diferența: în șablon, accesarea valorii returnează rezultatul blocului redat.

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

Dacă `mytheme/card` are câmpurile `heading` și `content`, blocul gazdă afișează `card_heading` și `card_content` în bara laterală. În șablon, `{{ a.card }}` afișează cardul redat. Funcționează atât cu blocurile obișnuite, cât și cu componentele.

### Eticheta HTML

Fiecare temă are blocuri în care nivelul titlului trebuie să se schimbe în funcție de context. Un H1 pe pagina principală, un H2 pe paginile secundare. În loc să creați de fiecare dată un câmp de selecție cu opțiuni definite în cod, acum există un tip de câmp `html-tag` dedicat, cu presetări incluse.

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

Presetări: `heading` (h1-h6), `text` (titluri + p, span, div), `structural` (div, section, article, aside, main, header, footer, nav), `all`. Sau transmiteți un tablou personalizat. `exclude` elimină etichete specifice din orice presetare.

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

## Bază de date

Aceasta este piesa centrală a versiunii. Adăugați un fișier `db.php` în orice director de bloc, iar Blockstudio generează cinci endpointuri CRUD REST, validează fiecare scriere conform schemei, gestionează automat backendul de stocare și oferă atât un client JavaScript (`bs.db()`), cât și un PHP API (`Db::get()`). Fără fișiere de migrare, clase de controller sau înregistrare de rute.

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

Doar schema respectivă generează un API complet funcțional, cu endpointuri de creare, listare, obținere, actualizare și ștergere, toate cu validarea intrărilor.

### Stocare

Cinci backenduri de stocare, fiecare potrivit pentru cazuri de utilizare diferite:

- **`table`**: Tabel MySQL personalizat, gestionat prin `dbDelta()`. Adăugarea de câmpuri în schemă adaugă coloane la următoarea încărcare a paginii. Opțiunea implicită pentru producție.
- **`sqlite`**: Un singur fișier SQLite în dosarul `db/` al blocului. Interogări SQL reale, mod WAL pentru citiri simultane și complet portabil. Copiați dosarul, copiați baza de date.
- **`jsonc`**: Un obiect JSON pe linie într-un fișier plat. Ușor de citit, cu versiuni controlabile, compatibil cu git.
- **`meta`**: Tablou JSON în metadatele articolului WordPress, asociat unui anumit articol.
- **`post_type`**: Fiecare înregistrare devine un articol WordPress într-un tip de articol personalizat. Câmpurile sunt stocate ca intrări individuale în metadatele articolului și pot fi interogate complet cu `WP_Query`.

### Clienți

Pe partea JavaScript, `bs.db()` vă oferă un client CRUD complet:

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

Trei utilitare complementare sunt incluse:

- **`bs.cache`**: Cache de interogări în memorie cu `get`, `set`, `invalidate` și `clear`. Partajat de toate apelurile de interogare și mutație.
- **`bs.query(key, fn, options)`**: Încadrează orice funcție asincronă într-un mecanism cu cache, deduplicare a cererilor și `staleTime` configurabil. Mai multe apeluri cu aceeași cheie, cât timp o cerere este în curs, returnează aceeași promisiune.
- **`bs.mutate(options)`**: Gestionează mutațiile optimiste cu revenire automată. Transmite un obiect cu stare reactivă, o acțiune (`create`, `update`, `delete`) și date optimiste. UI se actualizează instantaneu. Dacă apelul către server eșuează, starea revine la instantaneul de dinaintea mutației.

Împreună, acestea acoperă întregul ciclu de citire și scriere: `bs.query` pentru citiri din cache, `bs.mutate` pentru scrieri optimiste, `bs.cache` pentru control manual.

Pe partea PHP, clasa `Db` oferă aceleași operații:

```php
use Blockstudio\Db;

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

### Validare

Erorile de validare sunt returnate ca tablouri de erori pentru fiecare câmp, după modelul formatului `fieldErrors` al Zod. Mai multe reguli pot eșua pentru același câmp, iar structura facilitează asocierea erorilor cu câmpurile formularului din interfața frontală:

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

Apelurile personalizate `validate` de validare rulează pe server pentru tot ce nu pot acoperi regulile incluse: blocarea domeniilor, validarea între câmpuri, căutări externe.

### Date asociate utilizatorului

Pentru date asociate fiecărui utilizator, precum liste de lucruri de făcut, favorite sau schițe, setați `userScoped` la `true`, iar Blockstudio se ocupă de restul. Adaugă o coloană `user_id`, o completează automat la creare și filtrează fiecare interogare pentru utilizatorul curent. Actualizările și ștergerile verifică proprietarul. Fără câmp `user_id` manual, fără hook `before_create`, fără filtrare în RPC. O singură linie de configurare. Când folosiți stocarea `post_type`, `userScoped` se asociază cu `post_author` în locul unei coloane separate.

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

### Interogare periodică în timp real

Setați `'realtime' => true` în schema dvs., iar clientul va verifica automat dacă există modificări. Când se schimbă ceva pe server, magazinul Interactivity API se actualizează, iar UI se redă din nou fără nicio modificare JavaScript din partea dvs. Configurați cu `'realtime' => ['key' => 'todos', 'interval' => 5000]` pentru chei de stare și intervale personalizate. Verificarea periodică folosește compararea hashurilor pentru a menține cererile ușoare și se întrerupe când fila browserului este ascunsă.

### Securitate, hookuri, portabilitate

Endpointurile publice sunt protejate de un antet CSRF `X-BS-Token` injectat automat. Folosiți `'open'` când aveți nevoie de acces complet neautentificat, de exemplu pentru webhookuri primite.

Hookurile ciclului de viață sunt declanșate înainte și după fiecare operație de scriere. Definiți-le inline în `db.php` sau global prin acțiunile WordPress.

Câmpurile pot defini o cheie `component` pentru redarea formularelor pe baza schemei prin `bs_db_form()`.

Cu stocarea SQLite sau JSONC, întreaga aplicație se află într-un singur dosar: codul, logica, controlul accesului și datele. Copiați-l pentru implementare.

## RPC

Uneori, CRUD nu este suficient. Aveți nevoie de logică personalizată pe server: comutarea unei sarcini, trimiterea unei notificări, agregarea statisticilor. Pentru asta există `rpc.php`. Definiți o funcție PHP, apelați-o din interfața frontală cu `bs.fn()`, iar Blockstudio gestionează endpointul REST, autentificarea, protecția CSRF și serializarea JSON. Modelul este inspirat de [tRPC](https://trpc.io): proceduri definite pe server și apelate după nume de către client.

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

Scripturile inline (`script-inline.js`) detectează automat numele blocului din atributul `data-block` de pe eticheta scriptului, astfel că nu trebuie să-l transmiteți manual. Scripturile modulare îl transmit ca al treilea argument.

Opțiunile de control al accesului includ `public` (cu CSRF), `'open'` (fără protecție), șiruri de capabilități sau tablouri. Sunt acceptate și controlul metodei HTTP pentru fiecare funcție, hookurile ciclului de viață și apelarea între blocuri atât din JS, cât și din PHP.

## Cron

Sarcinile de fundal sunt definite într-un fișier `cron.php`. Setați un program și un apel invers, iar Blockstudio le înregistrează în WordPress Cron la inițializare. La dezactivarea extensiei, toate sunt eliminate corect din programare.

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

Sunt acceptate toate programele WordPress incluse, precum și intervalele personalizate prin filtrul `cron_schedules`.

## CLI

O nouă comandă `wp bs` acoperă întregul set de funcții Blockstudio: blocuri, bază de date, RPC, cron, setări, compilarea Tailwind, compilarea SCSS, câmpuri personalizate și gestionarea resurselor.

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

Toate comenzile acceptă `--format=json` pentru scripturi.

## Îmbunătățiri pentru repetor

### textMinimized pentru câmpurile obiect

Rândurile restrânse ale repetorului gestionează acum corect valorile câmpurilor obiect. Anterior, dacă `textMinimized` indica spre un câmp de link, afișa `[object Object]`. Acum, Blockstudio citește automat subproprietatea potrivită în funcție de tipul câmpului: `title` pentru linkuri, `value` pentru culori și gradienți, `icon` pentru pictograme. Puteți seta și o proprietate `key` explicită pentru a citi orice subproprietate doriți.

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

### RichText și MediaPlaceholder

Ambele componente de șablon funcționează acum în interiorul câmpurilor repetor, folosind notația cu paranteze drepte pentru a viza rândul corect. Titluri, paragrafe și zone de încărcare media editabile inline în fiecare rând al unui repetor.

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

## Condiții pentru câmpuri personalizate cu idStructure

Când folosiți un câmp personalizat cu `idStructure`, condițiile din definiția câmpului își rescriu acum automat ID-urile pentru a corespunde numelor extinse. Dacă grupul de câmpuri pentru dimensiunea fontului are o condiție pentru `enable` și îl extindeți cu `idStructure: "title_font_{id}"`, condiția face acum referire corect la `title_font_enable` în locul lui `enable` original.

Sunt acceptate și condițiile la nivel de referință. Adăugați `conditions` la referința câmpului personalizat pentru a le aplica simultan tuturor câmpurilor extinse.

## Argumente populate dinamic

Argumentele de populare pot face acum referire la alte atribute ale blocului folosind sintaxa `{attributes.*}`. Când atributul referit se schimbă, câmpul de selecție își reîncarcă automat opțiunile. Puteți lega selecțiile între ele: una pentru alegerea tipului de articol, alta pentru încărcarea articolelor de acel tip.

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

Schimbați `post_type` în "page", iar a doua selecție încarcă paginile. Schimbați-l în "post" și încarcă articolele. Funcționează cu orice tip de populare și orice atribut.

## Composer

Blockstudio funcționează acum când este încărcat din orice locație de sub `wp-content/`, nu doar din directorul pluginurilor. URL-urile resurselor sunt rezolvate printr-o constantă `BLOCKSTUDIO_URL` în loc de `plugins_url()`, astfel încât instalările incluse în teme funcționează direct:

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

Dependențele de execuție `composer.json` au fost curățate. Pachetele cu domeniu de nume (TailwindPHP, ScssPhp, Minify), deja incluse în `lib/`, nu mai sunt listate ca dependențe de execuție. Au rămas doar `php >= 8.2` și `plugin-update-checker`.

Toate cele trei metode de instalare (arhivă zip a pluginului, plugin prin Composer, inclus în temă prin Composer) pornesc cu același rezultat: activare completă WordPress, înregistrarea blocurilor și redarea pe interfața frontală.

Consultați documentația [Composer](https://blockstudio.dev/ro/docs/dev/composer/) pentru instrucțiuni de configurare.

## Profiler de performanță

Adăugați `?blockstudio-perf` la orice pagină URL, iar în partea de jos va apărea un panou de depanare cu timpii de redare pentru fiecare bloc, defalcarea pe faze și ratele de accesări din cache. Datele de temporizare sunt trimise și ca antete Server-Timing, vizibile în fila Network din DevTools ale browserului.

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

Activați-l permanent din setări pentru a analiza fiecare încărcare de pagină. Este vizibil doar pentru utilizatorii conectați cu capabilitatea `edit_posts`.

Etichetele de bloc cu închidere automată sunt acum stocate și în memoria cache. Când același bloc, cu atribute identice, apare de mai multe ori pe o pagină, redările ulterioare sar peste întregul flux al șablonului.

## Corecții de erori

- **Avertismente de depreciere PHP 8.4**: Au fost corectate avertismentele de depreciere `strpos()` și `str_replace()`, cauzate de transmiterea lui `null` către `add_submenu_page()`.

## Altele

- **Câmpuri de cod SCSS**: Câmpurile de cod acceptă `language: "scss"`. Valorile sunt compilate prin ScssPhp atât în editor, cât și pe interfața frontală.
- **Blocuri WordPress standard**: Directoarele Blockstudio pot conține ieșire `@wordpress/create-block` alături de blocurile Blockstudio. Acestea sunt înregistrate automat, fără cod separat pentru plugin.

---

Dacă doriți să vedeți modelul full-stack în acțiune, ghidul [Blocuri full-stack](https://blockstudio.dev/ro/guides/full-stack-blocks/) vă arată cum să construiți de la zero o aplicație cu sarcini pentru fiecare utilizator și un formular public de abonare la newsletter.
