
Blockstudio 7.2 amplia il framework in due direzioni contemporaneamente.

La prima riguarda **visibilità e flusso di lavoro** all'interno di un singolo progetto: una nuova panoramica nell'area di amministrazione, un browser di database, un browser del registro amministrativo e preludi SCSS per la configurazione condivisa di Sass.

La seconda riguarda **l'ecosistema intorno a Blockstudio**: un CLI di registro per distribuire blocchi (come shadcn per WordPress) e un'estensione PHPStan che porta nei template, nei tag di blocco, in `db.php`, `rpc.php`, `cron.php` e nei relativi file di schema la sicurezza dei tipi in stile TypeScript.

Entrambe le direzioni perseguono lo stesso obiettivo: rendere più facile comprendere, ampliare e condividere progetti Blockstudio più grandi.

## Esperienza nell'area di amministrazione

Due novità semplificano la navigazione nell'area wp-admin dei progetti più grandi.

### Panoramica nell'area di amministrazione

Ora Blockstudio include una schermata di amministrazione in **Strumenti > Blockstudio**. Offre un unico spazio per esaminare gli elementi registrati dal sistema nel filesystem.

La panoramica include schede dedicate a:

- Blocchi
- Estensioni
- Campi
- Pagine
- Schemi

Oltre alla panoramica, l'area di amministrazione ora include una sezione dedicata ai **Database**. Elenca ogni schema `Blockstudio\Db` registrato e consente di esaminare i record effettivi direttamente in wp-admin.

Invece di creare una griglia personalizzata di pannelli, la schermata usa le tabelle DataViews native di WordPress. In questo modo UI resta in linea con wp-admin e risulta pratica anche quando un progetto conta decine o centinaia di registrazioni.

In una piccola installazione, potete tenere a mente lo stato del runtime. In una base di codice più grande, non funziona più. Cominciate a porvi domande come:

- Quali blocchi sono effettivamente registrati in questo momento?
- Quali estensioni hanno come obiettivo `core/*` e quali i singoli blocchi?
- Quali pagine sono sincronizzate e a quali tipi di contenuto appartengono?
- Quali campi riutilizzabili esistono in questo progetto?
- Quali schemi sono registrati e quale backend di archiviazione usano?

Finora, per rispondere bisognava combinare la lettura delle cartelle, l'apertura dei file JSON e l'analisi di PHP. La panoramica offre una vera schermata di amministrazione.

Ogni scheda è pensata per rispondere a domande diverse:

- **Blocchi** mostra i tipi di blocco registrati, la modalità di rendering, la versione API e il numero di attributi
- **Estensioni** mostra i blocchi interessati, con priorità e dettagli di rendering
- **Campi** offre un inventario rapido delle definizioni di campi personalizzati riutilizzabili
- **Pagine** mostra le pagine sincronizzate basate su file, con tipo di contenuto, stato, motore dei template e stato della sincronizzazione
- **Schemi** mostra gli schemi di archiviazione registrati, con backend, numero di campi e ambito delle capability

Il browser del database è volutamente separato dal payload iniziale della panoramica. Invece di serializzare tutte le righe al caricamento della pagina, localizza subito solo gli schemi disponibili e recupera i record su richiesta quando aprite una scheda del database. In questo modo l'interfaccia di amministrazione resta utile anche quando un progetto contiene dataset più grandi dietro `db.php`.

Questa prima versione è volutamente incentrata sulle registrazioni basate su schemi. Non è una pagina delle impostazioni. È una pagina di ispezione.

Se non lo volete affatto, disattivatelo completamente:

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

### Browser del registro di amministrazione

Accanto alla panoramica c'è una seconda scheda: **Registro**. È un browser per i registri remoti dei blocchi configurati nel file `blocks.json` del vostro tema e vi permette di importare blocchi direttamente dall'interfaccia di amministrazione di WordPress senza toccare 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}"
      }
    }
  }
}
```

Il browser recupera ogni registro configurato, elenca tutti i blocchi disponibili e mostra se sono già installati in locale o pronti per l'importazione. Ogni riga ha un pulsante Importa che scarica i file del blocco nella directory configurata del tema. Per i blocchi già installati compare invece il pulsante Reimporta.

Sono supportati i registri autenticati nel formato oggetto con `headers`, inclusa l'interpolazione di `${ENV_VAR}`, così i token non finiscono mai nel controllo versione.

In questo modo esplorare e usare i registri diventa un'esperienza di amministrazione di prima classe, anziché un semplice flusso di lavoro CLI.

## CLI del registro

L'altra metà della gestione dei registri è un CLI autonomo: `blockstudio/registry`.

È uno strumento per blocchi WordPress in stile shadcn. Nessun pacchetto npm, nessuna fase di build. Eseguite un comando, il codice sorgente del blocco viene copiato nel vostro progetto e ne avete il pieno controllo.

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

Il CLI funziona con qualsiasi tipo di blocco: blocchi Blockstudio, output `@wordpress/create-block`, blocchi PHP semplici. Al registro non importa cosa ci sia nella cartella: legge il manifesto dei file da `registry.json` e copia esattamente quei file.

Gli autori dei blocchi pubblicano un `registry.json` a qualsiasi URL (contenuto grezzo GitHub, S3, un server personalizzato) che elenca i blocchi disponibili con metadati, dipendenze ed elenchi di file. Gli utenti aggiungono il URL al proprio `blocks.json` e recuperano i blocchi per nome.

Il CLI supporta:

- **Risoluzione delle dipendenze**: i blocchi possono dichiarare dipendenze da altri blocchi, risolte automaticamente con rilevamento dei cicli
- **Gestione dei conflitti tra più registri**: quando lo stesso nome di blocco è presente in più registri, il CLI vi chiede quale scegliere
- **Registri autenticati**: token bearer, autenticazione di base e intestazioni personalizzate con interpolazione delle variabili d'ambiente
- **TUI interattiva**: realizzata con Ink, con indicatori di attività, prompt di selezione e indicatori di avanzamento
- **Modalità non interattiva**: flag `--yes` e fallback automatico per CI e flussi tramite pipe
- **Ricerca ed elenco**: esplorate i registri dalla riga di comando

Il pacchetto include 130 test che coprono schemi, risoluzione delle dipendenze, recupero di HTTP, scrittura dei file, tutti i flussi dei comandi e la UI interattiva di Ink.

Documentazione completa: [blockstudio.dev/registry](https://blockstudio.dev/it/registry/).

## Estensione PHPStan

L'altra grande novità è `blockstudio/phpstan`: un'estensione PHPStan che offre agli utenti Blockstudio la sicurezza dei tipi che gli sviluppatori TypeScript si aspettano.

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

L'estensione legge gli schemi effettivi del vostro progetto durante l'analisi e restituisce i tipi risultanti a PHPStan. Ora supporta template PHP, Twig, Blade, tag dei blocchi, record di database tipizzati, percorsi delle impostazioni, nomi degli hook e convalida degli schemi in `block.json`, `field.json`, estensione JSON, `page.json`, `db.php`, `rpc.php`, `cron.php` e `blockstudio.json`.

### Template di blocco con tipi sicuri

Gli accessi ai campi su `$a` vengono convalidati rispetto al `block.json` corrispondente:

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

### Record di database con tipi sicuri

`Db::get()` restituisce un'istanza tipizzata basata sul vostro schema `db.php`. La struttura del record viene creata a partire dai campi effettivi:

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

### Convalida degli schemi

I file di schema non validi vengono individuati durante l'analisi: `block.json`, `field.json`, estensione JSON, `page.json`, `db.php`, `rpc.php`, `cron.php` e `blockstudio.json`. Nomi mancanti, tipi di campo errati, definizioni malformate e valori booleani abbreviati deprecati (`"tailwind": true` anziché l'oggetto annidato) vengono tutti segnalati con la riga esatta nel file sorgente.

### Convalida dei percorsi delle impostazioni

Le chiamate `Settings::get()` vengono convalidate rispetto allo schema delle impostazioni noto:

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

### Convalida dei nomi degli hook

Lo stesso vale per i nomi degli hook dei filtri e delle azioni:

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

L'estensione include anche stub per l'intera API pubblica API di Blockstudio: `Db`, `Settings`, `Field_Registry`, `Build` e gli helper globali. Avrete completamento automatico e controllo dei tipi per tutte le API di Blockstudio senza dover avere il codice sorgente del plugin sulla macchina di sviluppo.

## Strumenti per la creazione

Due ulteriori agevolazioni per la creazione completano la versione.

### Prelude globali SCSS

Blockstudio supportava già la compilazione SCSS, ma restava un fastidioso punto di attrito: la configurazione condivisa di Sass.

Per accedere a un insieme comune di variabili, funzioni o mixin, dovevate importarli in ogni file SCSS. Diventa presto ripetitivo, soprattutto con sistemi di design più grandi o toolkit Sass come Bootstrap.

La versione 7.2 aggiunge un hook prelude proprio per questo:

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

Insieme al filtro `blockstudio/assets/process/scss/import_paths` esistente, definite una volta un contesto condiviso di Sass, disponibile poi in ogni file compilato.

Il foglio di stile di un blocco può concentrarsi sugli stili di cui ha davvero bisogno:

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

Niente più import ripetuti in ogni risorsa del blocco. Non si tratta di una speciale "modalità di supporto a Bootstrap", ma di un hook generico per condividere Sass in un progetto, che provengano da Bootstrap o dal vostro toolkit interno.

### Definizioni API dei blocchi native PHP

La versione 7.2 aggiunge anche una sintassi facoltativa nativa di PHP per le API dei blocchi full-stack. Gli array restano l'impostazione predefinita e sono pienamente supportati. Non è stato sostituito nulla. Se preferite argomenti con nome, enum e attributi agli array di configurazione annidati, ora potete scegliere questo stile.

Per `rpc.php`, restituite un oggetto con metodi annotati:

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

Per `cron.php`, lo stesso approccio funziona con `#[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 {
    }
};
```

E per `db.php`, ora c'è un piccolo livello di builder:

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

Questo offre un equilibrio migliore per le basi di codice più grandi. Potete mantenere la semplicità del formato array quando vi serve e passare a un'API PHP più intuitiva da esplorare quando un blocco supera una manciata di campi o endpoint.

## Perché queste novità arrivano insieme

La panoramica di amministrazione, il browser dei registri, il CLI dei registri e l'estensione PHPStan rispondono tutti alla stessa domanda: come si fa a mantenere comprensibile un progetto Blockstudio man mano che cresce?

Gli strumenti di amministrazione rispondono a livello di progetto: visibilità su ciò che è registrato, possibilità di aggiungere blocchi dai registri e meno incertezze.

Il CLI risponde a livello di ecosistema: un modo per condividere blocchi tra progetti e team senza includerli in pacchetti npm né dover fare i conti con i sistemi di build.

L'estensione PHPStan risponde a livello di codice: intercetta accessi ai campi errati, refusi negli schemi e callback degli hook non funzionanti prima che causino problemi durante l'esecuzione.

Questa è la direzione generale della versione 7.2: meno incertezze, meno ripetizioni, più visibilità e ora anche una vera sicurezza dei tipi.

## Correzioni di bug

- **Campo Classes**: i nomi di classe personalizzati inseriti dall'utente venivano eliminati senza avviso quando il campo perdeva il focus, perché il validatore accettava solo classi dell'elenco predefinito Tailwind/impostazioni. Ora accetta qualsiasi stringa non vuota.
- **Campo Attributes**: rimuovendo una coppia di attributi, nei dati salvati restavano voci `null`. Sostituito lodash `unset()` (che imposta a null gli elementi dell'array) con `splice()` (che li rimuove).
- **Minificatore CSS**: il minificatore TailwindPHP rimuoveva gli spazi bianchi attorno a `+` dentro `calc()` e `clamp()`, generando CSS non validi come `calc(1rem+0.5vw)`. Correzione apportata a monte in TailwindPHP v1.3.1, con una scansione dei caratteri che tiene conto della profondità e rimuove gli spazi solo attorno ai combinatori dei selettori a profondità delle parentesi pari a 0.
- **Anteprima dell'inseritore di blocchi**: `$isPreview` era sempre `false` nell'anteprima dell'inseritore di blocchi, perché la chiave hash della cache di rendering non includeva la modalità di rendering. Ora i rendering nell'editor e nell'anteprima generano voci di cache separate.
- **Template annidato InnerBlocks**: il componente `<InnerBlocks template="..."/>` eliminava il terzo elemento (i figli) dalle tuple del template come `['core/group', {}, [['core/paragraph']]]`, generando blocchi contenitore vuoti. Ora conserva i figli annidati.
