
Blockstudio 7.1 é o primeiro lançamento de recursos desde a reescrita de v7. Enquanto v7 reconstruiu a base, a versão 7.1 acrescenta os elementos que transformam blocos em algo mais: uma camada de banco de dados, funções no servidor, tarefas agendadas e um CLI. Agora, uma pasta de blocos pode ser uma aplicação completa.

Veja tudo o que há de novo.

## Componentes

Sempre houve uma tensão entre os blocos usados pelos editores no inseridor e os blocos usados pelos desenvolvedores como elementos de construção de outras coisas. Um cartão, um selo, um widget de estatísticas, um campo de formulário. Eles precisam do pipeline completo de Blockstudio (atributos, templates, recursos, Tailwind), mas não têm motivo para aparecer no inseridor.

A versão 7.1 introduz componentes para resolver isso. Defina `"component": true` no seu block.json e o bloco passará por todo o pipeline de compilação, mas nunca será registrado no registro de tipos de bloco do WordPress. Ele não aparece no inseridor nem nos dados do editor enviados ao JavaScript, mas fica totalmente disponível para renderização programática.

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

Renderize-os a partir de PHP:

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

Ou usando a nova sintaxe de tag HTML:

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

## Tags de bloco

Agora, é possível incorporar blocos como tags HTML usando duas sintaxes intercambiáveis:

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

As duas produzem a mesma saída. Ambas funcionam com blocos Blockstudio e blocos principais do WordPress. Dentro de templates de bloco, elas são renderizadas automaticamente, sem necessidade de ativação explícita. Isso permite compor layouts inteiros diretamente no seu template com outros blocos:

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

As duas sintaxes podem ser aninhadas livremente. Os blocos Blockstudio são renderizados pelo pipeline completo (templates, Tailwind, recursos). Os blocos principais são renderizados por WordPress, usando os mesmos renderizadores que alimentam as [Páginas e padrões](https://blockstudio.dev/pt/docs/pages-and-patterns/).

Para renderização no nível da página (conteúdo de publicações, áreas de widgets), ative o recurso em `blockstudio.json`:

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

Listas de permissão e bloqueio controlam quais blocos podem ser renderizados por tags, usando padrões curinga. Os atributos `data-*` e `html-*` são aplicados ao elemento HTML raiz do bloco renderizado. É possível registrar renderizadores personalizados pelo filtro `blockstudio/block_tags/renderers`.

Nos bastidores, o analisador de tags é um novo scanner de strings leve que substitui completamente o DOMDocument. Ele processa tags aninhadas com rastreamento de profundidade, blocos contêiner recursivos e sintaxe mista em uma única passagem. Em benchmarks, analisa 1,000 tags planas em 2.4ms e 100 níveis de aninhamento em 3.7ms, sendo consistentemente mais rápido que DOMDocument e `WP_HTML_Tag_Processor` de WordPress. O mesmo analisador também processa elementos HTML brutos para [Páginas e padrões](https://blockstudio.dev/pt/docs/pages-and-patterns/), substituindo o analisador baseado em DOMDocument que antes processava `<p>`, `<div>` e outros elementos HTML.

## Novos tipos de campo

### Bloco

Um novo tipo de campo `block` que permite referenciar outro bloco Blockstudio como atributo. Os campos do bloco referenciado são expandidos em linha usando `idStructure` e `overrides`, exatamente como os campos personalizados. A diferença: no template, acessar o valor retorna a saída renderizada do bloco.

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

Se `mytheme/card` tiver os campos `heading` e `content`, o bloco hospedeiro terá `card_heading` e `card_content` na barra lateral. No template, `{{ a.card }}` gera o cartão renderizado. Funciona tanto com blocos regulares quanto com componentes.

### Tag HTML

Todo tema tem blocos cujo nível de título deve mudar conforme o contexto. Um H1 na página inicial, um H2 nas páginas internas. Em vez de criar um campo de seleção com opções codificadas sempre que isso acontece, agora há um tipo de campo `html-tag` dedicado, com predefinições integradas.

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

Predefinições: `heading` (h1-h6), `text` (títulos + p, span, div), `structural` (div, section, article, aside, main, header, footer, nav), `all`. Ou passe uma matriz personalizada. `exclude` remove tags específicas de qualquer predefinição.

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

## Banco de dados

Este é o destaque do lançamento. Adicione um arquivo `db.php` a qualquer diretório de bloco e Blockstudio gera cinco endpoints CRUD REST, valida cada gravação conforme o esquema, gerencia automaticamente o backend de armazenamento e fornece um cliente JavaScript (`bs.db()`) e um PHP API (`Db::get()`). Sem arquivos de migração, classes de controlador ou registro de rotas.

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

Só esse esquema já gera um API totalmente funcional, com endpoints para criar, listar, obter, atualizar e excluir, todos com validação de entrada.

### Armazenamento

Cinco backends de armazenamento, cada um adequado a diferentes casos de uso:

- **`table`**: tabela MySQL personalizada, gerenciada por `dbDelta()`. A adição de campos ao esquema acrescenta colunas no próximo carregamento da página. É a opção padrão para produção.
- **`sqlite`**: um único arquivo SQLite na pasta `db/` do bloco. Consultas SQL reais, modo WAL para leituras simultâneas e totalmente portátil. Copie a pasta, copie o banco de dados.
- **`jsonc`**: um objeto JSON por linha em um arquivo simples. Legível por humanos, com controle de versão e compatível com git.
- **`meta`**: matriz JSON em metadados de publicação WordPress, associada a uma publicação específica.
- **`post_type`**: cada registro se torna uma publicação WordPress em um tipo de publicação personalizado. Os campos são armazenados como entradas individuais de metadados da publicação, totalmente consultáveis com `WP_Query`.

### Clientes

No lado JavaScript, `bs.db()` oferece um 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);
```

Junto com ele, são fornecidos três utilitários complementares:

- **`bs.cache`**: cache de consultas em memória com `get`, `set`, `invalidate` e `clear`. Compartilhado por todas as chamadas de consulta e mutação.
- **`bs.query(key, fn, options)`**: envolve qualquer função assíncrona com cache, deduplicação de solicitações e `staleTime` configuráveis. Várias chamadas com a mesma chave enquanto uma solicitação está em andamento retornam a mesma promise.
- **`bs.mutate(options)`**: gerencia mutações otimistas com reversão automática. Passe um objeto de estado reativo, uma ação (`create`, `update`, `delete`) e dados otimistas. O UI é atualizado instantaneamente. Se a chamada ao servidor falhar, o estado volta ao snapshot anterior à mutação.

Juntos, esses recursos cobrem todo o ciclo de leitura e gravação: `bs.query` para leituras em cache, `bs.mutate` para gravações otimistas, `bs.cache` para controle manual.

No lado PHP, a classe `Db` oferece as mesmas operações:

```php
use Blockstudio\Db;

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

### Validação

Os erros de validação são retornados como matrizes de erros por campo, inspiradas no formato `fieldErrors` de Zod. Várias regras podem falhar no mesmo campo, e a estrutura facilita associar erros aos campos do formulário no frontend:

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

Os callbacks personalizados de `validate` são executados no servidor para tratar o que as regras integradas não cobrem: bloqueio de domínios, validação entre campos e consultas externas.

### Dados por usuário

Para dados por usuário, como tarefas, favoritos ou rascunhos, defina `userScoped` como `true` e Blockstudio cuidará do resto. Ele adiciona uma coluna `user_id`, define o valor automaticamente ao criar e filtra cada consulta pelo usuário atual. Atualizações e exclusões verificam a propriedade. Sem campo `user_id` manual, hook `before_create` ou filtros em RPC. Uma linha de configuração. Ao usar o armazenamento `post_type`, `userScoped` é mapeado para `post_author` em vez de uma coluna separada.

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

### Consulta periódica em tempo real

Defina `'realtime' => true` no seu esquema e o cliente consultará automaticamente as alterações. Quando algo mudar no servidor, o armazenamento Interactivity API será atualizado e o UI será renderizado novamente sem que você precise fazer alterações em JavaScript. Configure com `'realtime' => ['key' => 'todos', 'interval' => 5000]` para definir chaves de estado e intervalos personalizados. A consulta periódica compara hashes para reduzir o volume das solicitações e é pausada quando a aba do navegador está oculta.

### Segurança, hooks e portabilidade

Os endpoints públicos são protegidos por um cabeçalho CSRF `X-BS-Token` injetado automaticamente. Use `'open'` quando precisar de acesso realmente sem autenticação, por exemplo, para webhooks recebidos.

Os hooks de ciclo de vida são executados antes e depois de cada operação de gravação. Defina-os em linha em `db.php` ou globalmente por meio de ações WordPress.

Os campos podem definir uma chave `component` para renderização de formulários orientada pelo esquema por meio de `bs_db_form()`.

Com o armazenamento SQLite ou JSONC, toda a aplicação fica em uma única pasta: o código, a lógica, o controle de acesso e os dados. Copie-a para implantar.

## RPC

Às vezes, CRUD não basta. Você precisa de lógica personalizada no servidor: alternar uma tarefa, enviar uma notificação, agregar estatísticas. É para isso que serve `rpc.php`. Defina uma função PHP, chame-a no frontend com `bs.fn()` e Blockstudio cuidará do endpoint REST, da autenticação, da proteção CSRF e da serialização JSON. O padrão foi inspirado em [tRPC](https://trpc.io): procedimentos definidos no servidor e chamados pelo nome no 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' });
```

Scripts em linha (`script-inline.js`) detectam automaticamente o nome do bloco a partir do atributo `data-block` na tag do script, então você não precisa passá-lo manualmente. Scripts de módulo o recebem como terceiro argumento.

As opções de controle de acesso incluem `public` (com CSRF), `'open'` (sem proteção), strings de capacidade ou matrizes. Também são compatíveis o controle do método HTTP por função, os hooks de ciclo de vida e as chamadas entre blocos a partir de JS e PHP.

## Cron

As tarefas em segundo plano são definidas em um arquivo `cron.php`. Defina um agendamento e um callback, e Blockstudio os registra no WordPress Cron durante a inicialização. Quando o plugin é desativado, tudo é removido do agendamento corretamente.

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

Todos os agendamentos WordPress integrados são compatíveis, além de intervalos personalizados pelo filtro `cron_schedules`.

## CLI

Um novo comando `wp bs` abrange todos os recursos de Blockstudio: blocos, banco de dados, RPC, cron, configurações, compilação de Tailwind, compilação de SCSS, campos personalizados e gerenciamento 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 os comandos aceitam `--format=json` para uso em scripts.

## Melhorias no repetidor

### textMinimized para campos de objeto

Agora, as linhas recolhidas do repetidor processam corretamente os valores de campos de objeto. Antes, apontar `textMinimized` para um campo de link exibia `[object Object]`. Agora, Blockstudio lê automaticamente a subpropriedade correta de acordo com o tipo de campo: `title` para links, `value` para cores e gradientes, `icon` para ícones. Você também pode definir uma propriedade `key` explícita para ler qualquer subpropriedade desejada.

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

### RichText e MediaPlaceholder

Agora, os dois componentes de template funcionam dentro de campos de repetidor, com notação de colchetes para apontar para a linha correta. Títulos e parágrafos editáveis em linha, além de áreas para envio de mídia em cada linha do 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 %}
```

## Condições de campos personalizados com idStructure

Ao usar um campo personalizado com `idStructure`, os IDs das condições na definição do campo agora são reescritos automaticamente para corresponder aos nomes expandidos. Se o grupo de campos font-size tiver uma condição em `enable` e você o expandir com `idStructure: "title_font_{id}"`, a condição agora fará referência corretamente a `title_font_enable` em vez do `enable` original.

Também há suporte para condições no nível da referência. Adicione `conditions` à referência do campo personalizado para aplicá-las a todos os campos expandidos de uma só vez.

## Argumentos dinâmicos de preenchimento

Agora, os argumentos de preenchimento podem referenciar outros atributos de bloco usando a sintaxe `{attributes.*}`. Quando o atributo referenciado muda, o campo de seleção busca suas opções novamente de forma automática. Encadeie campos de seleção: um para escolher um tipo de publicação e outro que carrega publicações desse tipo.

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

Altere `post_type` para "page" e o segundo campo de seleção carregará páginas. Altere para "post" e ele carregará publicações. Funciona com qualquer tipo de preenchimento e qualquer atributo.

## Composer

Blockstudio agora funciona quando carregado de qualquer local dentro de `wp-content/`, não apenas do diretório de plugins. Os URLs dos recursos são resolvidos por meio de uma constante `BLOCKSTUDIO_URL` em vez de `plugins_url()`, então instalações integradas ao tema funcionam imediatamente:

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

As dependências de execução de `composer.json` foram simplificadas. Pacotes com escopo (TailwindPHP, ScssPhp, Minify) que já vêm incluídos em `lib/` não aparecem mais como dependências de execução. Restam apenas `php >= 8.2` e `plugin-update-checker`.

Os três métodos de instalação (arquivo zip do plugin, plugin via Composer, integrado ao tema via Composer) inicializam com o mesmo resultado: ativação completa de WordPress, registro de blocos e renderização no frontend.

Consulte a documentação de [Composer](https://blockstudio.dev/pt/docs/dev/composer/) para ver as instruções de configuração.

## Analisador de desempenho

Adicione `?blockstudio-perf` a qualquer URL de página para exibir um painel de depuração na parte inferior, com os tempos de renderização de cada bloco, detalhes por fase e taxas de acerto do cache. Os dados de tempo também são enviados como cabeçalhos Server-Timing, visíveis na aba Network das DevTools do navegador.

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

Ative-o permanentemente nas configurações para analisar todas as cargas de página. Só fica visível para usuários conectados com a capacidade `edit_posts`.

Agora, tags de bloco autocontidas também são armazenadas em cache na memória. Quando o mesmo bloco, com atributos idênticos, aparece várias vezes em uma página, as renderizações seguintes ignoram todo o pipeline de templates.

## Correções de bugs

- **Avisos de descontinuação do PHP 8.4**: corrigidos avisos de descontinuação de `strpos()` e `str_replace()` causados pela passagem de `null` para `add_submenu_page()`.

## Mais

- **Campos de código SCSS**: os campos de código são compatíveis com `language: "scss"`. Os valores são compilados por ScssPhp tanto no editor quanto no frontend.
- **Blocos WordPress padrão**: diretórios Blockstudio podem conter saídas `@wordpress/create-block` junto com blocos Blockstudio. Eles são registrados automaticamente, sem código de plugin separado.

---

Para ver o padrão full-stack em ação, o guia [Blocos full-stack](https://blockstudio.dev/pt/guides/full-stack-blocks/) mostra como criar do zero um aplicativo de tarefas por usuário e um formulário público de inscrição em newsletter.
