
Blockstudio 7.1 è la prima versione con nuove funzionalità dal rifacimento di v7. Dove v7 ha ricostruito le fondamenta, la versione 7.1 aggiunge gli elementi che trasformano i blocchi in qualcosa di più: un livello database, funzioni lato server, attività pianificate e un CLI. Ora una cartella di blocco può essere un'applicazione completa.

Ecco tutte le novità.

## Componenti

C'è sempre stata una certa tensione tra i blocchi che gli editor usano nell'inseritore e quelli che gli sviluppatori usano come elementi per costruire altro. Una scheda, un badge, un widget statistico, un campo modulo. Hanno bisogno dell'intera pipeline Blockstudio (attributi, template, risorse, Tailwind), ma non dovrebbero comparire nell'inseritore.

La versione 7.1 introduce i componenti per risolvere questo problema. Impostate `"component": true` nel vostro block.json e il blocco attraverserà l'intera pipeline di compilazione, senza però essere registrato nel registro dei tipi di blocco di WordPress. Non compare nell'inseritore né nei dati dell'editor inviati a JavaScript, ma è interamente disponibile per il rendering programmatico.

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

Eseguite il rendering da PHP:

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

Oppure usate la nuova sintassi dei tag HTML:

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

## Tag dei blocchi

Ora i blocchi possono essere incorporati come tag HTML usando due sintassi intercambiabili:

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

Entrambe producono lo stesso risultato. Entrambe funzionano con i blocchi Blockstudio e con i blocchi WordPress del core. Nei template dei blocchi, vengono renderizzati automaticamente senza alcuna configurazione aggiuntiva. Potete quindi comporre interi layout usando direttamente altri blocchi nel vostro template:

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

Le due sintassi possono essere annidate liberamente l'una nell'altra. I blocchi Blockstudio passano attraverso l'intera pipeline (template, Tailwind, risorse). I blocchi del core vengono renderizzati tramite WordPress, usando gli stessi renderer alla base di [Pagine e pattern](https://blockstudio.dev/it/docs/pages-and-patterns/).

Per il rendering a livello di pagina (contenuto degli articoli, aree widget), abilitatelo in `blockstudio.json`:

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

Gli elenchi di autorizzazione e blocco controllano quali blocchi possono essere renderizzati tramite tag usando pattern con caratteri jolly. Gli attributi `data-*` e `html-*` vengono applicati all'elemento radice HTML del blocco renderizzato. È possibile registrare renderer personalizzati tramite il filtro `blockstudio/block_tags/renderers`.

Dietro le quinte, il parser dei tag è un nuovo scanner leggero di stringhe che sostituisce completamente DOMDocument. Gestisce tag annidati tenendo traccia della profondità, blocchi contenitore ricorsivi e sintassi miste in un unico passaggio. Nei benchmark, analizza 1,000 tag piatti in 2.4ms e 100 livelli di annidamento in 3.7ms, risultando costantemente più veloce sia di DOMDocument sia di WordPress `WP_HTML_Tag_Processor`. Lo stesso parser gestisce anche l'analisi degli elementi HTML grezzi per [Pagine e pattern](https://blockstudio.dev/it/docs/pages-and-patterns/), sostituendo il parser basato su DOMDocument che in precedenza gestiva `<p>`, `<div>` e altri elementi HTML.

## Nuovi tipi di campo

### Blocco

Un nuovo tipo di campo `block` che permette di fare riferimento a un altro blocco Blockstudio come attributo. I campi del blocco referenziato vengono espansi in linea usando `idStructure` e `overrides`, proprio come i campi personalizzati. La differenza è che nel template, accedendo al valore si ottiene il risultato del rendering del blocco.

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

Se `mytheme/card` ha i campi `heading` e `content`, il blocco contenitore mostra `card_heading` e `card_content` nella barra laterale. Nel template, `{{ a.card }}` restituisce la scheda renderizzata. Funziona sia con i blocchi normali sia con i componenti.

### Tag HTML

Ogni tema ha blocchi in cui il livello del titolo deve cambiare in base al contesto. Un H1 nella home page, un H2 nelle pagine interne. Invece di creare ogni volta un campo di selezione con opzioni predefinite, ora è disponibile un tipo di campo `html-tag` dedicato con preset integrati.

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

Preset: `heading` (h1-h6), `text` (titoli + p, span, div), `structural` (div, section, article, aside, main, header, footer, nav), `all`. Oppure passate un array personalizzato. `exclude` rimuove tag specifici da qualsiasi preset.

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

## Database

È il fulcro di questa versione. Aggiungete un file `db.php` a qualsiasi cartella di blocco e Blockstudio genera cinque endpoint REST CRUD, convalida ogni scrittura in base allo schema, gestisce automaticamente il backend di archiviazione e fornisce un client JavaScript (`bs.db()`) e un PHP API (`Db::get()`). Nessun file di migrazione, classe controller o registrazione delle route.

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

Questo schema da solo genera un API perfettamente funzionante con endpoint per creare, elencare, recuperare, aggiornare ed eliminare dati, tutti con convalida degli input.

### Archiviazione

Cinque backend di archiviazione, ciascuno adatto a casi d'uso diversi:

- **`table`**: Tabella MySQL personalizzata gestita tramite `dbDelta()`. L’aggiunta di campi allo schema aggiunge colonne al caricamento della pagina successivo. È l’impostazione predefinita per la produzione.
- **`sqlite`**: Un singolo file SQLite nella cartella `db/` del blocco. Query SQL reali, modalità WAL per letture simultanee e portabilità completa. Copiate la cartella, copiate il database.
- **`jsonc`**: Un oggetto JSON per riga in un file semplice. Leggibile, con controllo di versione e compatibile con git.
- **`meta`**: Array JSON nei metadati del post WordPress, associato a un post specifico.
- **`post_type`**: Ogni record diventa un post WordPress in un tipo di post personalizzato. I campi vengono archiviati come singole voci di metadati del post, completamente interrogabili con `WP_Query`.

### Client

Sul lato JavaScript, `bs.db()` offre un client CRUD completo:

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

Insieme al client vengono fornite tre utilità complementari:

- **`bs.cache`**: una cache di query in memoria con `get`, `set`, `invalidate` e `clear`. Condivisa tra tutte le chiamate di query e mutazione.
- **`bs.query(key, fn, options)`**: avvolge qualsiasi funzione asincrona con caching, deduplicazione delle richieste e `staleTime` configurabile. Più chiamate con la stessa chiave mentre una richiesta è in corso restituiscono la stessa promise.
- **`bs.mutate(options)`**: gestisce mutazioni ottimistiche con rollback automatico. Passate un oggetto di stato reattivo, un'azione (`create`, `update`, `delete`) e dati ottimistici. L'UI si aggiorna immediatamente. Se la chiamata al server non riesce, lo stato torna allo snapshot precedente alla mutazione.

Insieme coprono l'intero ciclo di lettura e scrittura: `bs.query` per le letture memorizzate nella cache, `bs.mutate` per le scritture ottimistiche, `bs.cache` per il controllo manuale.

Sul lato PHP, la classe `Db` offre le stesse operazioni:

```php
use Blockstudio\Db;

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

### Convalida

Gli errori di convalida vengono restituiti come array di errori per campo, ispirati al formato `fieldErrors` di Zod. Più regole possono non essere superate per lo stesso campo e la struttura semplifica l'associazione degli errori ai campi del modulo nel frontend:

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

Le callback personalizzate `validate` vengono eseguite lato server per gestire i casi non coperti dalle regole integrate: blocco di domini, convalida tra campi e ricerche esterne.

### Dati associati all'utente

Per dati specifici dell'utente, come cose da fare, preferiti o bozze, impostate `userScoped` su `true` e Blockstudio penserà al resto. Aggiunge una colonna `user_id`, la imposta automaticamente alla creazione e filtra ogni query in base all'utente corrente. Gli aggiornamenti e le eliminazioni verificano la proprietà. Nessun campo `user_id` manuale, nessun hook `before_create`, nessun filtro in RPC. Basta una riga di configurazione. Con l'archiviazione `post_type`, `userScoped` corrisponde a `post_author` anziché a una colonna separata.

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

### Polling in tempo reale

Impostate `'realtime' => true` nello schema e il client controllerà automaticamente la presenza di modifiche. Quando cambia qualcosa sul server, lo store Interactivity API si aggiorna e UI esegue nuovamente il rendering senza che dobbiate apportare modifiche a JavaScript. Configurate `'realtime' => ['key' => 'todos', 'interval' => 5000]` per specificare chiavi di stato e intervalli personalizzati. Il polling usa il confronto degli hash per ridurre il carico delle richieste e si interrompe quando la scheda del browser è nascosta.

### Sicurezza, hook e portabilità

Gli endpoint pubblici sono protetti da un header CSRF `X-BS-Token` inserito automaticamente. Usate `'open'` quando serve un accesso completamente non autenticato, ad esempio per i webhook in ingresso.

Gli hook del ciclo di vita vengono eseguiti prima e dopo ogni operazione di scrittura. Definiteli in linea in `db.php` o globalmente tramite le azioni WordPress.

I campi possono definire una chiave `component` per il rendering dei moduli basato sullo schema tramite `bs_db_form()`.

Con l'archiviazione SQLite o JSONC, l'intera applicazione si trova in un'unica cartella: codice, logica, controllo degli accessi e dati. Copiatela per distribuirla.

## RPC

A volte CRUD non basta. Serve una logica personalizzata lato server: cambiare lo stato di un'attività, inviare una notifica, aggregare statistiche. A questo serve `rpc.php`. Definite una funzione PHP, chiamatela dal frontend con `bs.fn()` e Blockstudio gestirà l'endpoint REST, l'autenticazione, la protezione CSRF e la serializzazione JSON. Il modello si ispira a [tRPC](https://trpc.io): procedure definite lato server e chiamate dal client per nome.

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

Gli script in linea (`script-inline.js`) rilevano automaticamente il nome del blocco dall'attributo `data-block` sul tag dello script, quindi non occorre passarlo manualmente. Gli script modulo lo ricevono come terzo argomento.

Le opzioni di controllo degli accessi includono `public` (con CSRF), `'open'` (senza protezione), stringhe di capability o array. Sono supportati anche il controllo del metodo HTTP per funzione, gli hook del ciclo di vita e le chiamate tra blocchi da JS e PHP.

## Cron

Le attività in background si definiscono in un file `cron.php`. Impostate una pianificazione e una callback, e Blockstudio le registra con WordPress Cron durante l'inizializzazione. Quando il plugin viene disattivato, tutte le attività vengono annullate correttamente.

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

Sono supportate tutte le pianificazioni WordPress integrate, oltre agli intervalli personalizzati tramite il filtro `cron_schedules`.

## CLI

Un nuovo comando `wp bs` copre l'intero insieme di funzionalità Blockstudio: blocchi, database, RPC, cron, impostazioni, compilazione di Tailwind, compilazione di SCSS, campi personalizzati e gestione delle risorse.

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

Tutti i comandi supportano `--format=json` per gli script.

## Miglioramenti ai campi ripetitore

### textMinimized per i campi oggetto

Ora le righe dei campi ripetitore compresse gestiscono correttamente i valori dei campi oggetto. In precedenza, se associavate `textMinimized` a un campo link, veniva mostrato `[object Object]`. Ora Blockstudio legge automaticamente la proprietà secondaria corretta in base al tipo di campo: `title` per i link, `value` per colori e gradienti, `icon` per le icone. Potete anche impostare una proprietà `key` esplicita per leggere qualsiasi proprietà secondaria desideriate.

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

### RichText e MediaPlaceholder

Ora entrambi i componenti template funzionano nei campi ripetitore e supportano la notazione con parentesi quadre per selezionare la riga corretta. È possibile modificare in linea titoli e paragrafi e caricare contenuti multimediali in ogni riga del ripetitore.

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

## Condizioni dei campi personalizzati con idStructure

Quando usate un campo personalizzato con `idStructure`, gli ID delle condizioni nella definizione del campo vengono ora riscritti automaticamente per corrispondere ai nomi espansi. Se il vostro gruppo di campi per la dimensione del carattere ha una condizione su `enable` e lo espandete con `idStructure: "title_font_{id}"`, la condizione farà riferimento correttamente a `title_font_enable` anziché all'originale `enable`.

Sono supportate anche le condizioni a livello di riferimento. Aggiungete `conditions` al riferimento del campo personalizzato per applicarle contemporaneamente a ogni campo espanso.

## Argomenti dinamici di popolamento

Ora gli argomenti di popolamento possono fare riferimento ad altri attributi di blocco usando la sintassi `{attributes.*}`. Quando l'attributo referenziato cambia, il campo di selezione recupera automaticamente le proprie opzioni. Collegate più menu di selezione: uno per scegliere un tipo di contenuto, un altro per caricare gli articoli di quel tipo.

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

Impostate `post_type` su "page" e il secondo menu di selezione caricherà le pagine. Impostatelo su "post" e caricherà gli articoli. Funziona con qualsiasi tipo di popolamento e qualsiasi attributo.

## Composer

Ora Blockstudio funziona se caricato da qualsiasi percorso all'interno di `wp-content/`, non solo dalla directory dei plugin. Gli URL delle risorse vengono risolti tramite una costante `BLOCKSTUDIO_URL` anziché `plugins_url()`, quindi le installazioni incluse nei temi funzionano subito:

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

Le dipendenze runtime di `composer.json` sono state ripulite. I pacchetti con scope (TailwindPHP, ScssPhp, Minify) già inclusi in `lib/` non sono più elencati come dipendenze runtime. Restano solo `php >= 8.2` e `plugin-update-checker`.

Tutti e tre i metodi di installazione (file zip del plugin, plugin tramite Composer, tema con incluso tramite Composer) producono lo stesso risultato: attivazione completa di WordPress, registrazione dei blocchi e rendering frontend.

Consultate la documentazione [Composer](https://blockstudio.dev/it/docs/dev/composer/) per le istruzioni di configurazione.

## Profilo delle prestazioni

Aggiungete `?blockstudio-perf` a qualsiasi pagina URL e comparirà in basso un pannello di debug con i tempi di rendering per blocco, la suddivisione per fase e i tassi di cache hit. I dati sui tempi vengono inviati anche negli header Server-Timing, visibili nella scheda Network degli strumenti per sviluppatori del browser.

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

Abilitatelo in modo permanente dalle impostazioni per profilare ogni caricamento di pagina. È visibile solo agli utenti autenticati con la capability `edit_posts`.

Ora anche i tag di blocco autochiudenti vengono memorizzati in cache. Quando lo stesso blocco con attributi identici compare più volte in una pagina, i rendering successivi saltano l'intera pipeline dei template.

## Correzioni di bug

- **Avvisi di deprecazione di PHP 8.4**: corretti gli avvisi di deprecazione di `strpos()` e `str_replace()` causati dal passaggio di `null` a `add_submenu_page()`.

## Altro

- **Campi di codice SCSS**: i campi di codice supportano `language: "scss"`. I valori vengono compilati tramite ScssPhp sia nell'editor sia nel frontend.
- **Blocchi WordPress standard**: le directory Blockstudio possono contenere output `@wordpress/create-block` accanto ai blocchi Blockstudio. Vengono registrati automaticamente senza codice plugin aggiuntivo.

---

Se volete vedere il modello full stack in azione, la guida [Full-Stack Blocks](https://blockstudio.dev/it/guides/full-stack-blocks/) illustra passo passo come creare da zero un'app di cose da fare per utente e un modulo pubblico di iscrizione alla newsletter.
