
Blockstudio 7.1 es la primera versión con nuevas funciones desde la reescritura de v7. Mientras que v7 reconstruyó los cimientos, la versión 7.1 añade las piezas que convierten los bloques en algo más: una capa de base de datos, funciones del servidor, tareas programadas y una CLI. Ahora, una carpeta de bloques puede ser una aplicación completa.

Esto es todo lo nuevo.

## Componentes

Siempre ha existido cierta tensión entre los bloques que se usan en el insertador y los que utilizan los desarrolladores como componentes básicos para crear otras cosas. Una tarjeta, una insignia, un widget de estadísticas o un campo de formulario. Necesitan todo el proceso de compilación de Blockstudio (atributos, plantillas, recursos, Tailwind), pero no tienen por qué aparecer en el insertador.

La versión 7.1 introduce componentes para resolverlo. Configura `"component": true` en tu block.json y el bloque pasará por todo el proceso de compilación, pero no se registrará en el registro de tipos de bloques de WordPress. No aparece en el insertador ni en los datos del editor que se envían a JavaScript, pero está disponible para la representación programática.

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

Represéntalos desde PHP:

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

O con la nueva sintaxis de etiquetas HTML:

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

## Etiquetas de bloque

Ahora se pueden insertar bloques como etiquetas HTML con dos sintaxis intercambiables:

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

Ambas generan el mismo resultado. Funcionan tanto con los bloques Blockstudio como con los bloques del núcleo WordPress. Dentro de las plantillas de bloques, se representan automáticamente sin necesidad de habilitarlas. Así puedes componer diseños completos con otros bloques directamente en tu plantilla:

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

Las dos sintaxis se pueden anidar libremente. Los bloques Blockstudio pasan por todo el proceso de representación (plantillas, Tailwind, recursos). Los bloques del núcleo se representan mediante WordPress, con los mismos procesadores que usan [Páginas y patrones](https://blockstudio.dev/es/docs/pages-and-patterns/).

Para representar contenido a nivel de página (contenido de entradas y áreas de widgets), habilítalo en `blockstudio.json`:

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

Las listas de permitidos y bloqueados controlan qué bloques se pueden representar mediante etiquetas con patrones comodín. Los atributos `data-*` y `html-*` se transfieren al elemento raíz HTML del bloque representado. Puedes registrar procesadores personalizados mediante el filtro `blockstudio/block_tags/renderers`.

Por dentro, el analizador de etiquetas es un nuevo escáner de cadenas ligero que sustituye por completo a DOMDocument. Gestiona etiquetas anidadas mediante el seguimiento de la profundidad, bloques contenedores recursivos y sintaxis mixta en una sola pasada. En las pruebas de rendimiento, analiza 1,000 etiquetas planas en 2.4ms y 100 niveles de anidamiento en 3.7ms; es sistemáticamente más rápido que DOMDocument y `WP_HTML_Tag_Processor` de WordPress. El mismo analizador también procesa elementos HTML sin procesar para [Páginas y patrones](https://blockstudio.dev/es/docs/pages-and-patterns/), sustituyendo el analizador basado en DOMDocument que antes procesaba `<p>`, `<div>` y otros elementos HTML.

## Nuevos tipos de campo

### Bloque

Un nuevo tipo de campo `block` que permite hacer referencia a otro bloque Blockstudio como atributo. Los campos del bloque referenciado se expanden en línea mediante `idStructure` y `overrides`, igual que los campos personalizados. La diferencia es que, en la plantilla, al acceder al valor se obtiene el bloque representado.

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

Si `mytheme/card` tiene los campos `heading` y `content`, el bloque contenedor recibe `card_heading` y `card_content` en su barra lateral. En la plantilla, `{{ a.card }}` genera la tarjeta representada. Funciona tanto con bloques normales como con componentes.

### Etiqueta HTML

Todos los temas tienen bloques cuyo nivel de encabezado debe cambiar según el contexto: H1 en la página de inicio, H2 en las páginas internas. En vez de crear cada vez un campo de selección con opciones predefinidas, ahora hay un tipo de campo `html-tag` específico con ajustes preestablecidos integrados.

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

Ajustes preestablecidos: `heading` (h1-h6), `text` (encabezados + p, span, div), `structural` (div, section, article, aside, main, header, footer, nav), `all`. También puedes pasar una matriz personalizada. `exclude` elimina etiquetas específicas de cualquier ajuste preestablecido.

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

## Base de datos

Esta es la pieza central de la versión. Añade un archivo `db.php` a cualquier directorio de bloques y Blockstudio genera cinco endpoints CRUD REST, valida cada escritura según el esquema, gestiona automáticamente el backend de almacenamiento y proporciona un cliente JavaScript (`bs.db()`) y un PHP API (`Db::get()`). Sin archivos de migración, clases de controlador ni registro de rutas.

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

Ese esquema por sí solo genera un API totalmente funcional con endpoints para crear, listar, obtener, actualizar y eliminar, todos con validación de entradas.

### Almacenamiento

Cinco backends de almacenamiento, cada uno adaptado a distintos usos:

- **`table`**: tabla MySQL personalizada gestionada mediante `dbDelta()`. Al añadir campos al esquema, se agregan columnas en la siguiente carga de página. Es la opción predeterminada para producción.
- **`sqlite`**: un único archivo SQLite en la carpeta `db/` del bloque. Consultas SQL reales, modo WAL para lecturas simultáneas y total portabilidad. Copia la carpeta y tendrás una copia de la base de datos.
- **`jsonc`**: un objeto JSON por línea en un archivo plano. Legible, fácil de controlar con versiones y compatible con git.
- **`meta`**: una matriz JSON en los metadatos de la entrada WordPress, vinculada a una entrada específica.
- **`post_type`**: cada registro se convierte en una entrada WordPress de un tipo de contenido personalizado. Los campos se almacenan como entradas individuales de metadatos de la entrada, totalmente consultables con `WP_Query`.

### Clientes

En el lado de JavaScript, `bs.db()` te ofrece un cliente 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);
```

Incluye tres utilidades complementarias:

- **`bs.cache`**: una caché de consultas en memoria con `get`, `set`, `invalidate` y `clear`. Se comparte entre todas las consultas y llamadas de mutación.
- **`bs.query(key, fn, options)`**: envuelve cualquier función asíncrona con caché, deduplicación de solicitudes y `staleTime` configurable. Varias llamadas con la misma clave mientras una solicitud está en curso devuelven la misma promesa.
- **`bs.mutate(options)`**: gestiona mutaciones optimistas con reversión automática. Pasa un objeto de estado reactivo, una acción (`create`, `update`, `delete`) y datos optimistas. El UI se actualiza al instante. Si falla la llamada al servidor, el estado vuelve a la instantánea anterior a la mutación.

En conjunto, cubren todo el ciclo de lectura y escritura: `bs.query` para lecturas en caché, `bs.mutate` para escrituras optimistas y `bs.cache` para el control manual.

En el lado de PHP, la clase `Db` ofrece las mismas operaciones:

```php
use Blockstudio\Db;

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

### Validación

Los errores de validación se devuelven como matrices de errores por campo, siguiendo el formato `fieldErrors` de Zod. Pueden fallar varias reglas para un mismo campo, y esta estructura facilita asociar los errores con los campos del formulario en el frontend:

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

Las funciones de devolución de llamada `validate` personalizadas se ejecutan en el servidor para los casos que no cubren las reglas integradas: bloqueo de dominios, validación entre campos y consultas externas.

### Datos asociados al usuario

Para datos individuales, como listas de tareas, favoritos o borradores, configura `userScoped` como `true` y Blockstudio se encarga del resto. Añade una columna `user_id`, la asigna automáticamente al crear y filtra cada consulta para el usuario actual. Comprueba la propiedad al actualizar y eliminar. No hace falta un campo `user_id` manual, un hook `before_create` ni filtrar en RPC. Basta una línea de configuración. Si usas el almacenamiento `post_type`, `userScoped` se asigna a `post_author` en lugar de a una columna separada.

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

### Sondeo en tiempo real

Configura `'realtime' => true` en el esquema y el cliente buscará cambios automáticamente. Cuando algo cambie en el servidor, se actualizará el almacén Interactivity API y UI volverá a representarse sin que tengas que hacer ningún cambio de JavaScript. Configúralo con `'realtime' => ['key' => 'todos', 'interval' => 5000]` para definir claves de estado e intervalos personalizados. El sondeo compara hashes para reducir el tráfico de las solicitudes y se pausa cuando la pestaña del navegador está oculta.

### Seguridad, hooks y portabilidad

Los endpoints públicos están protegidos por un encabezado CSRF `X-BS-Token` que se inyecta automáticamente. Usa `'open'` cuando necesites acceso realmente sin autenticar, por ejemplo, para webhooks entrantes.

Los hooks del ciclo de vida se ejecutan antes y después de cada operación de escritura. Defínelos en línea en `db.php` o globalmente mediante acciones WordPress.

Los campos pueden definir una clave `component` para generar formularios basados en esquemas mediante `bs_db_form()`.

Con el almacenamiento SQLite o JSONC, toda la aplicación cabe en una carpeta: el código, la lógica, el control de acceso y los datos. Cópiala para implementarla.

## RPC

A veces, CRUD no basta. Necesitas lógica personalizada en el servidor: cambiar el estado de una tarea, enviar una notificación o agregar estadísticas. Para eso sirve `rpc.php`. Define una función PHP, llámala desde el frontend con `bs.fn()` y Blockstudio se encarga del endpoint REST, la autenticación, la protección CSRF y la serialización JSON. El patrón se inspira en [tRPC](https://trpc.io): procedimientos definidos en el servidor que se llaman por nombre desde el cliente.

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

Los scripts en línea (`script-inline.js`) detectan automáticamente el nombre del bloque a partir del atributo `data-block` de su etiqueta de script, así que no tienes que indicarlo manualmente. Los scripts de módulo lo reciben como tercer argumento.

Las opciones de control de acceso incluyen `public` (con CSRF), `'open'` (sin protección), cadenas de permisos o matrices. También se admiten el control de métodos HTTP por función, los hooks del ciclo de vida y las llamadas entre bloques desde JS y PHP.

## Cron

Las tareas en segundo plano se definen en un archivo `cron.php`. Configura una programación y una función de devolución de llamada, y Blockstudio las registra con WordPress Cron al inicializarse. Al desactivar el plugin, todas se cancelan correctamente.

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

Se admiten todas las programaciones integradas de WordPress, además de intervalos personalizados mediante el filtro `cron_schedules`.

## CLI

Un nuevo comando `wp bs` cubre todas las funciones de Blockstudio: bloques, base de datos, RPC, cron, ajustes, compilación de Tailwind, compilación de SCSS, campos personalizados y gestión de recursos.

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

Todos los comandos admiten `--format=json` para la creación de scripts.

## Mejoras en los repetidores

### textMinimized para campos de objeto

Ahora, las filas contraídas del repetidor gestionan correctamente los valores de los campos de objeto. Antes, si se asignaba `textMinimized` a un campo de enlace, se mostraba `[object Object]`. Ahora Blockstudio lee automáticamente la subpropiedad adecuada según el tipo de campo: `title` para enlaces, `value` para colores y degradados, `icon` para iconos. También puedes indicar una propiedad `key` explícita para leer cualquier subpropiedad.

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

### RichText y MediaPlaceholder

Ahora, ambos componentes de plantilla funcionan dentro de los campos de repetidor y admiten la notación con corchetes para apuntar a la fila correcta. Así puedes editar en línea encabezados y párrafos, y añadir zonas para subir archivos multimedia en cada fila de un repetidor.

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

## Condiciones de campos personalizados con idStructure

Al usar un campo personalizado con `idStructure`, las condiciones de su definición ahora reescriben automáticamente sus ID para que coincidan con los nombres expandidos. Si el grupo de campos de tamaño de fuente tiene una condición en `enable` y lo expandes con `idStructure: "title_font_{id}"`, la condición ahora hace referencia correctamente a `title_font_enable` en lugar del valor original `enable`.

También se admiten condiciones en el nivel de referencia. Añade `conditions` a la referencia del campo personalizado para aplicarlas de una vez a todos los campos expandidos.

## Argumentos de población dinámica

Ahora, los argumentos de población pueden hacer referencia a otros atributos de bloque mediante la sintaxis `{attributes.*}`. Cuando cambia el atributo referenciado, el campo de selección vuelve a obtener sus opciones automáticamente. Puedes encadenar selectores: uno para elegir un tipo de entrada y otro para cargar entradas de ese tipo.

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

Cambia `post_type` a "page" y el segundo selector cargará páginas. Cámbialo a "post" y cargará entradas. Funciona con cualquier tipo de población y cualquier atributo.

## Composer

Ahora, Blockstudio funciona al cargarse desde cualquier ubicación dentro de `wp-content/`, no solo desde el directorio de plugins. Las URL de los recursos se resuelven mediante una constante `BLOCKSTUDIO_URL` en lugar de `plugins_url()`, por lo que las instalaciones incluidas en temas funcionan directamente:

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

Se han depurado las dependencias de ejecución de `composer.json`. Los paquetes con ámbito (TailwindPHP, ScssPhp, Minify) que ya están incluidos en `lib/` ya no figuran como dependencias de ejecución. Solo quedan `php >= 8.2` y `plugin-update-checker`.

Los tres métodos de instalación (archivo zip del plugin, plugin mediante Composer y tema con Composer incluido) se inician con el mismo resultado: activación completa de WordPress, registro de bloques y representación en el frontend.

Consulta la [documentación de Composer](https://blockstudio.dev/es/docs/dev/composer/) para ver las instrucciones de configuración.

## Analizador de rendimiento

Añade `?blockstudio-perf` a cualquier URL de página y aparecerá un panel de depuración en la parte inferior con los tiempos de representación de cada bloque, el desglose por fase y las tasas de aciertos de caché. Los datos de tiempo también se envían en encabezados Server-Timing, visibles en la pestaña Red de DevTools del navegador.

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

Actívalo de forma permanente en los ajustes para analizar cada carga de página. Solo lo pueden ver los usuarios con sesión iniciada que tengan el permiso `edit_posts`.

Ahora también se guardan en caché en memoria las etiquetas de bloque autocerradas. Cuando un mismo bloque con atributos idénticos aparece varias veces en una página, las representaciones posteriores omiten todo el proceso de la plantilla.

## Correcciones de errores

- **Avisos de obsolescencia de PHP 8.4**: se corrigieron los avisos de obsolescencia de `strpos()` y `str_replace()` causados al pasar `null` a `add_submenu_page()`.

## Más

- **Campos de código SCSS**: los campos de código admiten `language: "scss"`. Los valores se compilan mediante ScssPhp tanto en el editor como en el frontend.
- **Bloques WordPress estándar**: los directorios Blockstudio pueden contener salidas `@wordpress/create-block` junto con bloques Blockstudio. Se registran automáticamente sin necesidad de código de plugin adicional.

---

Si quieres ver el patrón de pila completa en acción, la [guía de bloques de pila completa](https://blockstudio.dev/es/guides/full-stack-blocks/) explica paso a paso cómo crear desde cero una aplicación de tareas para usuarios individuales y un formulario público para suscribirse a un boletín.
