
Blockstudio 7.1 est la première version fonctionnelle depuis la réécriture de v7. Alors que v7 a
reconstruit les fondations, la version 7.1 ajoute les éléments qui font des blocs bien plus que de simples blocs : une couche de base de données, des fonctions serveur, des tâches planifiées et un CLI. Un dossier de bloc peut désormais constituer une application complète.

Voici toutes les nouveautés.

## Composants

Il y a toujours eu une tension entre les blocs utilisés par les éditeurs dans l’inséreur et ceux que les développeurs utilisent comme briques pour créer d’autres éléments. Une carte, un badge, un widget de statistiques, un champ de formulaire. Ils ont besoin du pipeline Blockstudio complet (attributs, modèles, ressources, Tailwind), mais n’ont rien à faire dans l’inséreur.

La version 7.1 introduit les composants pour résoudre ce problème. Définissez `"component": true` dans votre block.json : le bloc passe par tout le pipeline de compilation, mais n’est jamais enregistré dans le registre des types de blocs de WordPress. Il n’apparaît pas dans l’inséreur ni dans les données de l’éditeur envoyées à JavaScript, mais reste entièrement disponible pour le rendu programmatique.

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

Effectuez leur rendu depuis PHP :

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

Ou utilisez la nouvelle syntaxe de balise HTML :

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

## Balises de bloc

Les blocs peuvent désormais être intégrés sous forme de balises HTML, selon deux syntaxes interchangeables :

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

Les deux syntaxes produisent le même résultat. Elles fonctionnent avec les blocs Blockstudio et les blocs WordPress natifs. Dans les modèles de bloc, le rendu est automatique, sans activation préalable. Vous pouvez ainsi composer des mises en page entières à partir d’autres blocs directement dans votre modèle :

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

Les deux syntaxes peuvent s’imbriquer librement. Les blocs Blockstudio passent par le pipeline complet (modèles, Tailwind, ressources). Les blocs natifs sont rendus par WordPress au moyen des mêmes moteurs de rendu que ceux de [Pages and Patterns](https://blockstudio.dev/fr/docs/pages-and-patterns/).

Pour le rendu à l’échelle d’une page (contenu d’article, zones de widgets), activez cette fonctionnalité dans `blockstudio.json` :

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

Les listes d’autorisation et de refus déterminent quels blocs peuvent être rendus via des balises, à l’aide de motifs génériques. Les attributs `data-*` et `html-*` sont transmis à l’élément racine HTML du bloc rendu. Des moteurs de rendu personnalisés peuvent être enregistrés avec le filtre `blockstudio/block_tags/renderers`.

En interne, l’analyseur de balises est un nouveau scanner de chaînes léger qui remplace entièrement DOMDocument. Il gère les balises imbriquées avec suivi de la profondeur, les blocs conteneurs récursifs et les syntaxes mixtes en un seul passage. Lors des tests de performances, il analyse 1,000 balises plates en 2.4ms et 100 niveaux d’imbrication en 3.7ms, toujours plus vite que DOMDocument et le `WP_HTML_Tag_Processor` de WordPress. Le même analyseur gère aussi l’analyse des éléments HTML bruts pour [Pages and Patterns](https://blockstudio.dev/fr/docs/pages-and-patterns/), remplaçant l’analyseur basé sur DOMDocument qui traitait auparavant `<p>`, `<div>` et d’autres éléments HTML.

## Nouveaux types de champs

### Bloc

Un nouveau type de champ `block` qui permet de référencer un autre bloc Blockstudio comme attribut. Les champs du bloc référencé sont développés en ligne avec `idStructure` et `overrides`, exactement comme les champs personnalisés. La différence : dans le modèle, l’accès à la valeur renvoie le rendu du bloc.

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

Si `mytheme/card` possède des champs `heading` et `content`, le bloc hôte affiche `card_heading` et `card_content` dans sa barre latérale. Dans le modèle, `{{ a.card }}` produit le rendu de la carte. Fonctionne avec les blocs classiques comme avec les composants.

### Balise HTML

Dans chaque thème, le niveau de titre de certains blocs doit varier selon le contexte : H1 sur la page d’accueil, H2 sur les pages internes. Au lieu de créer chaque fois un champ de sélection avec des options codées en dur, un type de champ `html-tag` dédié propose désormais des préréglages intégrés.

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

Préréglages : `heading` (h1-h6), `text` (titres + p, span, div), `structural` (div, section, article, aside, main, header, footer, nav), `all`. Vous pouvez aussi transmettre un tableau personnalisé. `exclude` retire des balises spécifiques de n’importe quel préréglage.

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

## Base de données

C’est la pièce maîtresse de cette version. Ajoutez un fichier `db.php` à n’importe quel répertoire de bloc et Blockstudio génère cinq points de terminaison REST CRUD, valide chaque écriture selon le schéma, gère automatiquement le moteur de stockage et fournit un client JavaScript (`bs.db()`) ainsi qu’un PHP API (`Db::get()`). Aucun fichier de migration, aucune classe de contrôleur, aucune déclaration de 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']],
        ],
    ],
];
```

Ce schéma suffit à produire un API entièrement fonctionnel avec des points de terminaison de création, de liste, de lecture, de mise à jour et de suppression, tous dotés d’une validation des entrées.

### Stockage

Cinq moteurs de stockage, chacun adapté à des cas d’utilisation différents :

- **`table`** : table MySQL personnalisée gérée via `dbDelta()`. L’ajout de champs au schéma ajoute des colonnes au prochain chargement de page. Valeur par défaut en production.
- **`sqlite`** : un seul fichier SQLite dans le dossier `db/` du bloc. De vraies requêtes SQL, le mode WAL pour les lectures simultanées et une portabilité complète. Copiez le dossier, copiez la base de données.
- **`jsonc`** : un objet JSON par ligne dans un fichier plat. Lisible par un humain, contrôlable par version, compatible avec git.
- **`meta`** : tableau JSON dans les métadonnées de publication WordPress, associé à une publication spécifique.
- **`post_type`** : chaque enregistrement devient une publication WordPress dans un type de publication personnalisé. Les champs sont stockés comme entrées de métadonnées de publication individuelles, entièrement interrogeables avec `WP_Query`.

### Clients

Côté JavaScript, `bs.db()` vous fournit 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);
```

Trois utilitaires complémentaires l’accompagnent :

- **`bs.cache`** : cache de requêtes en mémoire avec `get`, `set`, `invalidate` et `clear`. Partagé entre tous les appels de requête et de mutation.
- **`bs.query(key, fn, options)`** : enveloppe toute fonction asynchrone avec mise en cache, déduplication des requêtes et `staleTime` configurables. Plusieurs appels avec la même clé pendant une requête en cours renvoient la même promesse.
- **`bs.mutate(options)`** : gère les mutations optimistes avec retour arrière automatique. Transmettez un objet d’état réactif, une action (`create`, `update`, `delete`) et des données optimistes. L’état UI est mis à jour instantanément. En cas d’échec de l’appel serveur, l’état revient à son instantané précédent la mutation.

Ensemble, ils couvrent tout le cycle de lecture et d’écriture : `bs.query` pour les lectures en cache, `bs.mutate` pour les écritures optimistes, `bs.cache` pour le contrôle manuel.

Côté PHP, la classe `Db` fournit les mêmes opérations :

```php
use Blockstudio\Db;

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

### Validation

Les erreurs de validation sont renvoyées sous forme de tableaux d’erreurs par champ, selon le format `fieldErrors` de Zod. Plusieurs règles peuvent échouer pour un même champ, et cette structure facilite l’association des erreurs aux champs du formulaire côté frontend :

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

Les fonctions de rappel `validate` personnalisées s’exécutent côté serveur pour les cas non couverts par les règles intégrées : blocage de domaines, validation entre champs, recherches externes.

### Données propres à l’utilisateur

Pour les données propres à chaque utilisateur, comme les listes de tâches, les favoris ou les brouillons, définissez `userScoped` sur `true` et Blockstudio s’occupe du reste. Il ajoute une colonne `user_id`, la renseigne automatiquement à la création et filtre chaque requête selon l’utilisateur actuel. Les mises à jour et suppressions vérifient la propriété. Aucun champ `user_id` manuel, aucun hook `before_create`, aucun filtrage dans RPC. Une ligne de configuration. Avec le stockage `post_type`, `userScoped` correspond à `post_author` plutôt qu’à une colonne distincte.

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

### Interrogation périodique en temps réel

Définissez `'realtime' => true` dans votre schéma et le client interrogera automatiquement les changements. Lorsqu’une modification survient sur le serveur, le magasin Interactivity API est mis à jour et UI effectue un nouveau rendu sans qu’aucune modification JavaScript ne soit nécessaire de votre côté. Configurez `'realtime' => ['key' => 'todos', 'interval' => 5000]` pour définir des clés d’état et des intervalles personnalisés. L’interrogation utilise une comparaison de hachages pour alléger les requêtes et s’interrompt lorsque l’onglet du navigateur est masqué.

### Sécurité, hooks et portabilité

Les points de terminaison publics sont protégés par un en-tête CSRF `X-BS-Token` injecté automatiquement. Utilisez `'open'` pour un accès réellement non authentifié, par exemple pour des webhooks entrants.

Les hooks de cycle de vie s’exécutent avant et après chaque opération d’écriture. Définissez-les en ligne dans `db.php` ou globalement via les actions WordPress.

Les champs peuvent définir une clé `component` pour générer des formulaires à partir du schéma via `bs_db_form()`.

Avec le stockage SQLite ou JSONC, toute l’application tient dans un dossier : le code, la logique, le contrôle d’accès et les données. Copiez-le pour déployer l’application.

## RPC

Parfois, le CRUD ne suffit pas. Vous avez besoin d’une logique serveur personnalisée : basculer une tâche, envoyer une notification, agréger des statistiques. C’est le rôle de `rpc.php`. Définissez une fonction PHP, appelez-la depuis le frontend avec `bs.fn()`, et Blockstudio gère le point de terminaison REST, l’authentification, la protection CSRF et la sérialisation JSON. Le modèle s’inspire de [tRPC](https://trpc.io) : procédures définies côté serveur et appelées par leur nom depuis le 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' });
```

Les scripts en ligne (`script-inline.js`) détectent automatiquement le nom du bloc depuis l’attribut `data-block` de leur balise script ; vous n’avez donc pas à le transmettre manuellement. Les scripts de module le transmettent comme troisième argument.

Les options de contrôle d’accès comprennent `public` (avec CSRF), `'open'` (sans protection), des chaînes de capacités ou des tableaux. Le contrôle de méthode HTTP par fonction, les hooks de cycle de vie et les appels entre blocs depuis JS et PHP sont également pris en charge.

## Cron

Les tâches en arrière-plan sont définies dans un fichier `cron.php`. Définissez une planification et une fonction de rappel, et Blockstudio les enregistre auprès de WordPress Cron à l’initialisation. À la désactivation de l’extension, toutes les tâches sont proprement déprogrammées.

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

Toutes les planifications WordPress intégrées sont prises en charge, ainsi que les intervalles personnalisés via le filtre `cron_schedules`.

## CLI

Une nouvelle commande `wp bs` couvre l’ensemble des fonctionnalités Blockstudio : blocs, base de données, RPC, cron, réglages, compilation de Tailwind, compilation de SCSS, champs personnalisés et gestion des ressources.

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

Toutes les commandes prennent en charge `--format=json` pour les scripts.

## Améliorations du répéteur

### textMinimized pour les champs objet

Les lignes de répéteur réduites gèrent désormais correctement les valeurs des champs objet. Auparavant, si `textMinimized` pointait vers un champ de lien, il affichait `[object Object]`. Désormais, Blockstudio lit automatiquement la sous-propriété adaptée au type de champ : `title` pour les liens, `value` pour les couleurs et dégradés, `icon` pour les icônes. Vous pouvez aussi définir une propriété `key` explicite pour lire n’importe quelle sous-propriété.

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

### RichText et MediaPlaceholder

Les deux composants de modèle fonctionnent désormais dans les champs répéteurs avec la notation entre crochets pour cibler la bonne ligne. Les titres, paragraphes et zones de téléversement de médias peuvent être modifiés en ligne dans chaque ligne d’un répéteur.

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

## Conditions de champ personnalisé avec idStructure

Lorsqu’un champ personnalisé utilise `idStructure`, les conditions de sa définition réécrivent désormais automatiquement leurs ID pour correspondre aux noms développés. Si votre groupe de champs de taille de police dépend de `enable` et que vous le développez avec `idStructure: "title_font_{id}"`, la condition référence désormais correctement `title_font_enable` au lieu de l’élément d’origine `enable`.

Les conditions au niveau de la référence sont également prises en charge. Ajoutez `conditions` à la référence du champ personnalisé pour les appliquer simultanément à chaque champ développé.

## Arguments de remplissage dynamiques

Les arguments de remplissage peuvent désormais référencer d’autres attributs de bloc avec la syntaxe `{attributes.*}`. Lorsque l’attribut référencé change, les options du champ de sélection sont automatiquement récupérées à nouveau. Enchaînez les sélections : l’une pour choisir un type de publication, l’autre pour charger les publications de ce type.

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

Remplacez `post_type` par « page » et la deuxième sélection charge les pages. Remplacez-le par « post » et elle charge les publications. Fonctionne avec tout type de remplissage et tout attribut.

## Composer

Blockstudio fonctionne désormais lorsqu’il est chargé depuis n’importe quel emplacement sous `wp-content/`, et pas seulement depuis le répertoire des extensions. Les URL des ressources sont résolues via une constante `BLOCKSTUDIO_URL` plutôt que `plugins_url()` ; les installations intégrées à un thème fonctionnent donc immédiatement :

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

Les dépendances d’exécution de `composer.json` ont été nettoyées. Les packages à portée limitée (TailwindPHP, ScssPhp, Minify), déjà inclus dans `lib/`, ne figurent plus parmi les dépendances d’exécution. Seuls `php >= 8.2` et `plugin-update-checker` restent.

Les trois méthodes d’installation (archive d’extension, extension via Composer, intégration au thème via Composer) aboutissent au même résultat : activation complète de WordPress, enregistrement des blocs et rendu côté frontend.

Consultez la [documentation de Composer](https://blockstudio.dev/fr/docs/dev/composer/) pour les instructions de configuration.

## Profiler de performances

Ajoutez `?blockstudio-perf` à la page URL et un panneau de débogage apparaît en bas, avec les temps de rendu par bloc, le détail par phase et les taux de réussite du cache. Les données de chronométrage sont également envoyées dans les en-têtes Server-Timing, visibles dans l’onglet Réseau des outils de développement du navigateur.

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

Activez-le définitivement dans les réglages pour profiler chaque chargement de page. Visible uniquement par les utilisateurs connectés disposant de la capacité `edit_posts`.

Les balises de bloc autofermantes sont désormais aussi mises en cache en mémoire. Lorsque le même bloc avec des attributs identiques apparaît plusieurs fois sur une page, les rendus suivants ignorent tout le pipeline de modèles.

## Corrections de bugs

- **Avertissements de dépréciation de PHP 8.4** : correction des avertissements de dépréciation de `strpos()` et `str_replace()` provoqués par la transmission de `null` à `add_submenu_page()`.

## Plus

- **Champs de code SCSS** : les champs de code prennent en charge `language: "scss"`. Les valeurs sont compilées avec ScssPhp dans l’éditeur comme sur le frontend.
- **Blocs WordPress standards** : les répertoires Blockstudio peuvent contenir une sortie `@wordpress/create-block` en plus des blocs Blockstudio. Ils sont enregistrés automatiquement, sans code d’extension distinct.

---

Pour découvrir le modèle full-stack en action, le [guide Full-Stack Blocks](https://blockstudio.dev/fr/guides/full-stack-blocks/) vous explique comment créer de zéro une application de tâches par utilisateur et une inscription publique à une newsletter.
