
Blockstudio 7 a sosit. Aceasta este cea mai mare lansare din istoria proiectului: o rescriere completă, de la zero, a întregii baze de cod. Fiecare clasă, fiecare hook, fiecare linie de cod a fost reconstruită de la zero, cu accent pe PHP modern, standardele de codare WordPress și mentenabilitatea pe termen lung.

Dar nu este vorba doar despre refactorizare. Blockstudio 7 aduce funcții noi importante, precum pagini și modele bazate pe fișiere, un sistem de stocare a metadatelor postării, integrarea SEO și un parser complet nou HTML-la-bloc, care le susține pe toate. În plus, Blockstudio este acum complet gratuit și open source.

Să vedem toate noutățile.

## Gratuit și open source

Lucrez la Blockstudio din 2020 și am lansat zeci de versiuni de-a lungul anilor. Cei care l-au folosit l-au apreciat, dar găsirea unei piețe potrivite pentru un framework comercial de blocuri WordPress a fost mereu o provocare.

Ce a schimbat situația sunt LLM-urile. Asistenții de programare AI sunt acum suficient de buni pentru a scrie cod pentru blocuri, dar au nevoie de structuri curate, bazate pe fișiere, cu care să lucreze. Marcajul blocurilor WordPress este greoi: comentarii HTML serializate cu atribute JSON încorporate, combinate cu structura DOM. E greu pentru oameni și și mai greu pentru LLM-uri să-l scrie corect.

Abordarea Blockstudio, centrată pe fișiere, a fost mereu concepută pentru simplitate: un `block.json` și un șablon PHP într-un dosar. Fără intrări în baza de date, fără React, fără pas de compilare. Cu v7, această filozofie merge și mai departe. Parserul HTML-la-bloc vă permite să scrieți HTML simplu, care este apoi convertit automat în marcaj valid pentru blocuri. Totul rămâne în sistemul de fișiere. Singurele scrieri în baza de date sunt sincronizările de pagini solicitate explicit prin PHP API sau CLI, iar acestea sunt controlate de șabloanele de fișiere.

Publicarea Blockstudio ca open source este pasul următor firesc. Cu cât mai multe LLM-uri se antrenează pe cod Blockstudio, cu atât devin mai bune la generarea acestuia. O bază de cod deschisă, documentație deschisă și un fișier de context AI predefinit [pe care îl poate folosi orice instrument](https://blockstudio.dev/ro/docs/dev/ai/): așa creați cel mai bun mediu pentru dezvoltarea asistată de AI WordPress.

Pluginul complet este disponibil pe [GitHub](https://github.com/inline0/blockstudio) pentru ca oricine să îl folosească, să creeze fork-uri și să contribuie. Fără chei de licență, fără acces contra cost, fără funcții blocate.

## Funcționalități noi

### Pagini bazate pe fișiere

Aceasta este una dintre cele mai importante noutăți din versiunea 7.0. Acum puteți defini pagini WordPress întregi ca șabloane de fișiere, care se sincronizează cu baza de date ca conținut nativ de blocuri atunci când invocați API sau CLI pentru sincronizarea paginilor.

Creați un dosar cu un `page.json` și un fișier șablon:

```json title="page.json"
{
  "name": "about",
  "title": "About Us",
  "slug": "about",
  "postStatus": "publish"
}
```

```php title="index.php"
<div class="about-page">
  <h1>About Us</h1>
  <p>Welcome to our site.</p>
</div>
```

Rulați `wp bs pages sync` pentru ca Blockstudio să analizeze HTML în blocuri WordPress și să creeze sau să actualizeze pagina în baza de date.

#### Îmbinarea blocurilor după cheie

Când șabloanele se sincronizează, modificările utilizatorilor ar fi în mod normal suprascrise. Atributul `key` rezolvă problema păstrând conținutul utilizatorilor între sincronizări:

```html title="index.php"
<h1 key="hero-title">Default Title</h1>
<p key="hero-description">Default description.</p>
```

Blocurile cu chei identice își păstrează conținutul editat de utilizator atunci când șablonul se actualizează. Blocurile fără chei sunt înlocuite complet.

#### Legături între blocuri

Ca alternativă la chei, puteți folosi WordPress core [Legături între blocuri API](https://developer.wordpress.org/block-editor/reference-guides/block-api/block-bindings/) pentru a conecta blocurile direct la metadatele postării. Aceasta nu este o funcție Blockstudio, ci o WordPress API nativă. Blockstudio transmite pur și simplu atributul `metadata` către marcajul de bloc generat. Conținutul se află în meta în loc de marcajul blocului, astfel încât sincronizările șabloanelor nu distrug niciodată modificările utilizatorilor. Datele pot fi, de asemenea, interogate prin `WP_Query` și sunt disponibile prin REST API.

```html title="index.php"
<h1 metadata='{"bindings":{"content":{"source":"core/post-meta","args":{"key":"hero_title"}}}}'>
  Default Title
</h1>
```

Ambele abordări pot fi folosite în același șablon.

#### Controale de editare

Paginile acceptă `blockEditingMode` și `templateLock` pentru a controla ce pot modifica utilizatorii:

```json title="page.json"
{
  "name": "landing",
  "title": "Landing Page",
  "blockEditingMode": "contentOnly",
  "templateLock": "all"
}
```

Aceasta blochează structura paginii, permițând totuși utilizatorilor să editeze textul și conținutul media. Elementele individuale pot suprascrie setarea la nivel de pagină cu un atribut `blockEditingMode` din șablon.

#### Fixarea la ID-uri de postare

Folosiți `postId` pentru a lega un șablon de pagină de o postare WordPress existentă, prevenind paginile duplicate și asigurându-vă că șablonul actualizează mereu postarea corectă:

```json title="page.json"
{
  "name": "home",
  "title": "Home",
  "postId": 2
}
```

Pentru detalii complete, consultați [Documentația paginilor](https://blockstudio.dev/ro/docs/pages-and-patterns/pages/).

### Modele bazate pe fișiere

La fel ca în cazul paginilor, acum puteți defini modele de blocuri ca șabloane de fișiere. Scrieți modelul în HTML, iar Blockstudio îl analizează în marcaj de bloc și îl înregistrează ca model de bloc nativ WordPress. Acestea apar în inseratorul de blocuri și pot fi plasate oriunde de către utilizatori.

```json title="pattern.json"
{
  "name": "hero-section",
  "title": "Hero Section",
  "categories": ["featured"],
  "keywords": ["hero", "banner"]
}
```

```html title="index.php"
<div class="hero">
  <h1>Welcome</h1>
  <p>Get started today.</p>
</div>
```

Spre deosebire de pagini, modelele nu creează intrări în baza de date. Sunt înregistrate în memorie la fiecare încărcare a paginii. Consultați [Documentația modelelor](https://blockstudio.dev/ro/docs/pages-and-patterns/patterns/).

### Parser HTML-la-bloc

Atât paginile, cât și modelele sunt susținute de un nou parser HTML care convertește șabloanele HTML standard în marcaj de blocuri WordPress. Acesta gestionează automat blocurile container (precum grupurile și coloanele) și blocurile frunză (precum paragrafele și titlurile). Parserul folosește o arhitectură de randare bazată pe trait-uri, ceea ce facilitează extinderea cu suport pentru tipuri suplimentare de blocuri prin filtrul `blockstudio/parser/renderers`:

```php title="functions.php"
add_filter( 'blockstudio/parser/renderers', function ( $renderers, $parser ) {
    $renderers['acme/hero'] = function ( $element, $attrs, $parser ) {
        $content = $parser->get_inner_html( $element );
        $html    = '<div class="acme-hero">' . $content . '</div>';

        return array(
            'blockName'    => 'acme/hero',
            'attrs'        => $attrs,
            'innerBlocks'  => array(),
            'innerHTML'    => $html,
            'innerContent' => array( $html ),
        );
    };

    return $renderers;
}, 10, 2 );
```

După înregistrare, puteți folosi blocul în orice șablon de pagină sau model:

```html title="index.php"
<block name="acme/hero" background="/hero.jpg">
  <h1>Welcome to our site</h1>
</block>
```

### Stocare

Câmpurile își pot stoca acum valorile în meta-ul postării sau în opțiunile site-ului, pe lângă atributele blocului. Este o schimbare majoră:

```json title="block.json"
{
  "id": "subtitle",
  "type": "text",
  "label": "Subtitle",
  "storage": {
    "type": "postMeta"
  }
}
```

Cu valori în meta-ul postării, puteți:

- Interoga postări după valorile câmpurilor folosind `WP_Query` și `meta_query`
- Accesa datele câmpurilor prin REST API pentru configurații headless
- Partaja date cu alte pluginuri, precum instrumentele SEO și straturile de caching

De asemenea, puteți stoca valori în tabelul de opțiuni pentru setări globale, la nivelul întregului site:

```json title="block.json"
{
  "id": "phone",
  "type": "text",
  "label": "Phone Number",
  "storage": {
    "type": "option",
    "optionKey": "company_phone"
  }
}
```

Consultați [Documentația stocării](https://blockstudio.dev/ro/docs/blocks/storage/) pentru API completă.

### Câmpuri personalizate

Definițiile de câmpuri reutilizabile pot fi acum partajate între mai multe blocuri. Definiți o singură dată un set de câmpuri, apoi faceți referire la el din orice bloc. Astfel eliminați repetițiile când mai multe blocuri au aceeași structură de câmpuri.

Creați un `field.json` în directorul blockstudio:

```json title="fields/hero/field.json"
{
  "name": "hero",
  "title": "Hero Section",
  "attributes": [
    { "id": "heading", "type": "text", "label": "Heading", "default": "Hello World" },
    { "id": "description", "type": "textarea", "label": "Description" }
  ]
}
```

Apoi faceți referire la acesta din orice bloc folosind prefixul `custom/`:

```json title="block.json"
{
  "blockstudio": {
    "attributes": [
      { "type": "custom/hero", "idStructure": "hero_{id}" }
    ]
  }
}
```

Proprietatea `idStructure` prefixează ID-ul fiecărui câmp, astfel încât `heading` devine `hero_heading`. De asemenea, puteți suprascrie proprietăți individuale ale câmpurilor pentru fiecare instanță, folosind cheia `overrides`.

Consultați [Documentația câmpurilor personalizate](https://blockstudio.dev/ro/docs/blocks/attributes/custom-fields/).

### Tailwind CSS v4

Suportul Tailwind a fost reconstruit complet pentru v4. În loc să compileze pe partea clientului prin CDN și să salveze pe disc la salvarea postării (abordarea v6), Blockstudio 7 compilează Tailwind pe partea serverului la fiecare solicitare frontend prin [TailwindPHP](https://github.com/dnnsjsk/tailwindphp). Fără Node.js, fără CLI, fără pas de compilare.

Compilarea folosește caching bazat pe candidați: Blockstudio extrage toate numele de clase CSS din rezultatul final HTML, le sortează și le hash-uiește împreună cu configurația CSS, apoi verifică dacă există un fișier în cache. Aceleași clase produc aceeași potrivire în cache, chiar dacă se schimbă conținutul HTML din jur (nonce-uri, marcaje temporale, conținut dinamic).

Configurarea folosește sintaxa CSS, cu v4 Tailwind pe primul loc. Definiți teme personalizate și clase utilitare direct în `blockstudio.json` sau prin filtrul `blockstudio/tailwind/css`:

```php title="functions.php"
add_filter('blockstudio/tailwind/css', function ($css) {
  return $css . '
    @theme {
      --color-brand: #4f46e5;
    }

    @layer utilities {
      .container-narrow {
        max-width: 48rem;
        margin-inline: auto;
      }
    }
  ';
});
```

În editorul de blocuri, un script Tailwind CDN inclus oferă previzualizare live în timp ce scrieți. Tipul de câmp `classes` oferă completare automată pentru toate utilitarele Tailwind. Frontendul folosește întotdeauna CSS compilat pe server, injectat ca etichetă de stil inline înainte de `</head>`.

Pentru configurarea completă, consultați documentația [Tailwind](https://blockstudio.dev/ro/docs/tailwind/).

### Interactivitate API

Blockstudio acceptă acum [WordPress Interactivity API](https://developer.wordpress.org/block-editor/reference-guides/interactivity-api/). Activați-o în block.json:

```json title="block.json"
{
  "blockstudio": {
    "interactivity": true
  }
}
```

Adăugați directivele `data-wp-*` la șablon:

```php title="index.php"
<div useBlockProps
     data-wp-interactive="myBlock"
     data-wp-context='{ "isOpen": false }'>
  <button data-wp-on--click="actions.toggle"
          data-wp-bind--aria-expanded="context.isOpen">
    Toggle
  </button>
  <div data-wp-bind--hidden="!context.isOpen">
    This content is toggled by the button.
  </div>
</div>
```

Și creați un `script.js` cu logica magazinului:

```javascript title="script.js"
import { store, getContext } from '@wordpress/interactivity';

store('myBlock', {
  actions: {
    toggle: () => {
      const context = getContext();
      context.isOpen = !context.isOpen;
    },
  },
});
```

Blockstudio gestionează importmap-ul, încărcarea modulelor și procesarea directivelor atât în frontend, cât și în editorul de blocuri. Blocurile care folosesc doar directive declarative cu `data-wp-context` (precum `data-wp-bind--hidden` sau `data-wp-text`) funcționează fără niciun JavaScript. Starea pe partea serverului prin `wp_interactivity_state()` este, de asemenea, acceptată în frontend.

Pentru configurarea completă, consultați [Documentația Interactivity](https://blockstudio.dev/ro/docs/blocks/interactivity/).

### Analiza conținutului SEO

Blocurile Blockstudio sunt dinamice, așa că în mod implicit conținutul câmpurilor lor nu este vizibil pentru pluginurile SEO. Blockstudio 7 rezolvă problema prin integrări automate pentru Yoast SEO, Rank Math și SEOPress. Valorile text din câmpurile `text`, `textarea`, `richtext`, `wysiwyg` și `link` (inclusiv rândurile imbricate ale câmpurilor repeater) sunt extrase și transmise către analiza conținutului din fiecare plugin. Pluginurile SEO pot analiza acum corect conținutul blocurilor pentru densitatea cuvintelor cheie, lizibilitate și alte valori. Nu este necesară nicio configurare.

### Rânduri implicite pentru câmpurile repeater

Câmpurile repeater acceptă acum o proprietate `default` cu un tablou de rânduri precompletate. Când se inserează un bloc, repeater-ul este populat cu rândurile și valorile specificate, atât în editor, cât și în frontend:

```json title="block.json"
{
  "id": "features",
  "type": "repeater",
  "label": "Features",
  "default": [
    { "title": "Fast", "icon": "bolt" },
    { "title": "Secure", "icon": "shield" }
  ],
  "attributes": [
    { "id": "title", "type": "text", "label": "Title" },
    { "id": "icon", "type": "text", "label": "Icon" }
  ]
}
```

Proprietatea `min` funcționează și cu valorile implicite la nivel de câmp: dacă un repeater are `min: 3`, iar câmpurile sale interne au valori `default`, rândurile generate automat sunt precompletate cu valorile implicite respective, în loc să rămână goale.

## Îmbunătățiri și remedieri

- **Repeater `min` cu valori implicite pentru câmpuri**: rândurile minime generate automat folosesc acum valorile implicite la nivel de câmp atât în frontend, cât și în editor
- **Stiluri pentru editorul Tailwind**: Tailwind CSS compilat este injectat acum în iframe-ul editorului de blocuri, alături de CDN, astfel încât regulile `@apply` personalizate și configurația temei să funcționeze în editor
- **Fișier de context AI [AI context file](https://blockstudio.dev/ro/docs/dev/ai/)**: `blockstudio-llm.txt` a fost reconstruit ca fișier static, alcătuit din documentația v7 completă și schemele JSON deduplicate (aproximativ 48k de tokenuri), înlocuind generarea dinamică din v6
- **Fereastră separată pentru câmpul de cod**: câmpul de cod poate fi deschis acum într-o fereastră separată, cu anulare/refacere independente și evidențierea sintaxei JavaScript
- **Compilare pe server Tailwind v4**: consultați secțiunea [Tailwind de mai sus](#tailwind-css-v4)
- **API versiunea 3**: blocurile se redau acum corect în editorul cu iframe, inclusiv în editorul site-ului și în previzualizările responsive
- **Notație cu punct pentru resurse**: convenție mai clară de denumire a fișierelor pentru sufixele resurselor (`*.inline.css`, `*.editor.js`, `*.scoped.css`)
- Avertisment `bs_render_block()` remediat pentru `WP_Block_Supports` la utilizarea `useBlockProps`
- Remediere pentru câmpurile condiționale care nu respectau valorile implicite la prima încărcare
- Remediere pentru semnele dolar eliminate din conținutul `<RichText />` în frontend
- Funcția `populate` a fost remediată pentru a funcționa cu taxonomiile înregistrate de alte pluginuri
- Eroare null `optionsPopulate` remediată în contexte WPML

## Cum funcționează

### Rescriere completă

Aceasta nu este o refactorizare sau o curățare a codului. Fiecare clasă a fost rescrisă de la zero. Rezultatul este o bază de cod mai curată și mai modulară, mai ușor de întreținut și de extins.

### PHP modern

Blockstudio 7 necesită PHP 8.2+ și folosește declarații de tip moderne peste tot.

## Modificări incompatibile

Fiind o actualizare majoră, versiunea 7.0 include mai multe modificări incompatibile. Cele mai multe au mecanisme de compatibilitate retroactivă, dar ar trebui să le verificați înainte de actualizare. Pentru un ghid complet de migrare, consultați [documentația de migrare la v7](https://blockstudio.dev/ro/docs/dev/migration/v7/).

### Numele hook-urilor folosesc acum snake_case

Toate hook-urile PHP au fost redenumite din camelCase în snake_case, conform convențiilor WordPress core:

```php title="functions.php"
// Before (v6)
add_filter('blockstudio/settings/blockEditor/cssClasses', function() {
    return ['my-stylesheet'];
});

// After (v7)
add_filter('blockstudio/settings/block_editor/css_classes', function() {
    return ['my-stylesheet'];
});
```

Numele camelCase vechi funcționează în continuare, dar vă recomandăm să le actualizați.

### Comutatorul câmpului este dezactivat implicit

Proprietatea `switch` are acum valoarea implicită `false` în loc de `true`. În v6, fiecare câmp avea pe marginea stângă un comutator invizibil, activat implicit. În v7, comutatorul este opțional și folosește o pictogramă de ochi vizibilă în eticheta câmpului. Dacă vă bazați pe comportamentul implicit al comutatorului, adăugați `"switch": true` la definițiile câmpurilor.

### Denumirea fișierelor de resurse folosește notația cu punct

Sufixele resurselor folosesc acum puncte în loc de cratime (`style.inline.css` în loc de `style-inline.css`). Notația veche cu cratimă funcționează în continuare, dar notația cu punct este convenția recomandată de acum înainte.

### Prefixul de import npm

Importurile de module ES folosesc acum `npm:` în loc de `blockstudio/`:

```javascript title="script.js"
// Before (v6)
import confetti from "blockstudio/canvas-confetti@1.6.0";

// After (v7)
import confetti from "npm:canvas-confetti@1.6.0";
```

Prefixul `blockstudio/` este acceptat în continuare pentru compatibilitate cu versiunile anterioare.

### Funcții eliminate

**Zona de administrare și editorul de cod.** Pagina de setări de administrare WordPress și editorul încorporat pentru codul blocurilor au fost eliminate. Toată configurarea se face acum prin filtrele `blockstudio.json` și PHP, astfel încât configurația să fie în controlul versiunilor, alături de blocuri.

Editorul de cod era util în versiunile anterioare pentru previzualizarea blocurilor, dar nu a ajuns niciodată la nivelul unui mediu real de dezvoltare. De-a lungul anilor, mai multe funcții ale pluginului au fost limitate, deoarece nu puteau fi acceptate în editorul independent. De asemenea, nu avea cum să înlocuiască un IDE complet. Eliminarea lui permite pluginului să se concentreze fără compromisuri asupra dezvoltării bazate pe fișiere.

**Cheie de licență.** Nu mai este necesară. Blockstudio este gratuit și open source.

**Biblioteca de blocuri.** Biblioteca încorporată „Blockstudio Elements” (Gallery, Slider, Image Comparison, Code, Icon) a fost eliminată. Acestea erau blocuri exemplu predefinite, incluse în plugin. Dacă le foloseați, copiați dosarele blocurilor din v6 în directorul blockstudio al temei.

## Primii pași

Instalați Blockstudio 7 și creați primul bloc în câteva minute. Consultați ghidul [Primii pași](https://blockstudio.dev/ro/docs/general/getting-started/) pentru instrucțiuni pas cu pas sau ghidul de migrare [v7](https://blockstudio.dev/ro/docs/dev/migration/v7/) dacă faceți upgrade de la v6.

Codul sursă complet este pe [GitHub](https://github.com/inline0/blockstudio). Sunt binevenite problemele raportate, PR-urile și feedbackul.
